构建可用于商业用途的生成式人工智能系统

Building Business-Ready Generative AI Systems

利用代理、记忆和LLM构建以人为中心的企业级生成式人工智能系统

Build Human-Centered Generative AI Systems with Agents, Memory, and LLMs for Enterprise

丹尼斯·罗斯曼

Denis Rothman

构建可用于商业用途的生成式人工智能系统

Building Business-Ready Generative AI Systems

版权所有 © 2025 Packt Publishing

Copyright © 2025 Packt Publishing

版权所有。未经出版商事先书面许可，不得以任何形式或任何方式复制、存储于检索系统或传播本书的任何部分，但嵌入评论文章或评论中的简短引文除外。

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

本书在编写过程中已尽一切努力确保所提供信息的准确性。然而，本书所含信息均不提供任何明示或暗示的担保。作者、Packt Publishing及其经销商和分销商均不对因本书直接或间接造成的任何损失承担责任。

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing已尽力通过正确使用大写字母提供本书中提及的所有公司和产品的商标信息。然而，Packt Publishing无法保证此信息的准确性。

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

投资组合总监：格宾·乔治

Portfolio Director: Gebin George

客户关系负责人：阿里·阿比迪

Relationship Lead: Ali Abidi

项目经理： Prajakta Naik

Project Manager: Prajakta Naik

内容工程师： Tanya D'cruz

Content Engineer: Tanya D’cruz

技术编辑： Rahul Limbachiya

Technical Editor: Rahul Limbachiya

文案编辑： Safis Editing

Copy Editor: Safis Editing

索引员：赫曼吉尼·巴里

Indexer: Hemangini Bari

校对员： Tanya D'cruz

Proofreader: Tanya D’cruz

美术指导：沙塔努·扎加德

Production Designer: Shantanu Zagade

增长主管：尼米莎·杜阿

Growth Lead: Nimisha Dua

营销负责人：Dipali Malwatkar

Marketing Owner: Dipali Malwatkar

首次发布：2025年7月

First published: July 2025

生产参考编号：1220725

Production reference: 1220725

由 Packt Publishing Ltd. 出版。

Published by Packt Publishing Ltd.

格罗夫纳酒店

Grosvenor House

圣保罗广场11号

11 St Paul’s Square

伯明翰

Birmingham

英国 B3 1RB。

B3 1RB, UK.

ISBN 978-1-83702-069-0

ISBN 978-1-83702-069-0

www.packtpub.com

www.packtpub.com

谨以此书献给我的家人和朋友，他们是我快乐的源泉。

I would like to dedicate this book to my family and friends who are my source of happiness.

丹尼斯·罗斯曼

– Denis Rothman

贡献者

Contributors

关于作者

About the author

丹尼斯·罗斯曼毕业于索邦大学和巴黎狄德罗大学。他是首批获得专利的词嵌入矩阵算法和人工智能对话代理的先驱之一。在其职业生涯早期，丹尼斯开发了一款认知型自然语言处理聊天机器人，该机器人被酩悦香槟和其他全球品牌采用，用作自动化语言训练工具。之后，他为空客（前身为法国宇航公司）创建了一款人工智能资源优化器，该优化器被IBM和服装行业的领先企业所采用。他开发的先进计划与排程（APS）解决方案已在全球范围内广泛应用，并影响了各行业的供应链智能。

Denis Rothman is a graduate of Sorbonne University and Paris-Diderot University. He pioneered one of the first patented word2matrix embedding algorithms and AI-powered conversational agents. Early in his career, Denis developed a cognitive NLP chatbot adopted by Moët & Chandon and other global brands as an automated language trainer. He later created an AI resource optimizer for Airbus (formerly Aérospatiale), which was implemented by IBM and leading companies in the apparel industry. His Advanced Planning and Scheduling (APS) solution, used worldwide, has shaped supply chain intelligence across sectors.

丹尼斯通过他的著作，与致力于塑造有目的性的人工智能的全球思想家、建设者和学习者群体分享了他的创新经验。

Through his books, Denis shares his experience of innovation with a global community of thinkers, builders, and learners committed to shaping AI with purpose.

关于评论者

About the reviewers

Martin Yanev是一位经验丰富的软件工程师，近十年来一直致力于解决航空航天和医疗技术等领域的复杂挑战。作为菲奇堡州立大学计算机科学系的讲师和教授，Martin 对 OpenAI 的 API 套件非常熟悉，并擅长构建、训练和改进实用的人工智能系统。他也是一位知名的作家，致力于让更多人了解人工智能开发。

Martin Yanev is an experienced software engineer who has spent nearly a decade tackling complex challenges in fields like aerospace and medical technology. As an instructor and professor of computer science at Fitchburg State University, Martin is deeply familiar with OpenAI’s suite of APIs and excels at building, training, and refining practical AI systems. He is also a recognized author who enjoys making AI development accessible to others.

Leonid Ganeline是一位机器学习工程师，在自然语言处理领域拥有丰富的经验。他曾在多家初创公司工作，负责开发人工智能应用、模型和生产系统。他是 LangChain 的积极贡献者，尤其关注模型量化和人工智能代理架构。

Leonid Ganeline is a machine learning engineer with extensive experience in natural language processing. He has worked at several startups, creating AI applications, models, and production systems. He is an active contributor to LangChain, with a particular interest in model quantization and AI agent architectures.

拉瓦尼亚·古普塔 (Lavanya Gupta)毕业于卡内基梅隆大学 (CMU) 语言技术研究所 (LTI)。她目前在摩根大通担任高级人工智能/机器学习应用专员，就职于其机器学习卓越中心 (MLCOE)。她曾在多个活动和会议上发表演讲，包括 WiDS、PyData、SciPy、Illuminate AI 和 TensorFlow 用户组。此外，她还积极通过与 Anita Borg 和 Women in Coding and Data Science (WiCDS) 合作的导师项目，为职业生涯早期的专业人士提供支持。

Lavanya Gupta is a Carnegie Mellon University (CMU) alumna from the Language Technologies Institute (LTI). She currently works as a Senior AI/ML Applied Associate at JPMorgan Chase, within their specialized Machine Learning Center of Excellence (MLCOE). She has delivered several talks at events and conferences, including WiDS, PyData, SciPy, Illuminate AI, and the TensorFlow User Group. She also actively supports early-career professionals through mentorship programs with Anita Borg and Women in Coding and Data Science (WiCDS).

订阅即可免费获取电子书

Subscribe for a Free eBook

新框架、演进的架构、研究成果发布、生产故障——AI_Distilled每周都会为从事 LLM 和 GenAI 系统实战的工程师和研究人员提供一份简报，帮您过滤掉各种干扰信息。立即订阅，即可免费获得电子书，以及每周更新的深度见解，助您保持专注，掌握最新资讯。

New frameworks, evolving architectures, research drops, production breakdowns—AI_Distilled filters the noise into a weekly briefing for engineers and researchers working hands-on with LLMs and GenAI systems. Subscribe now and receive a free eBook, along with weekly insights that help you stay focused and informed.

订阅请访问https://packt.link/TRO5B或扫描下方二维码。

Subscribe at https://packt.link/TRO5B or scan the QR code below.

前言

Preface

在快速发展的人工智能领域，仅靠独立的大型语言模型（LLM）无法创造商业价值。这本全面的指南将帮助您成为一名生成式人工智能架构师，从零开始构建功能强大的 ChatGPT 级系统，并使其适应任何平台。您将超越基础聊天机器人，开发能够进行语义和情感分析的系统——其核心是上下文感知人工智能控制器。

In the rapidly evolving AI landscape, standalone large language models (LLMs) alone don’t deliver business value. This comprehensive guide enables you to become a generative AI architect, building powerful ChatGPT-grade systems from scratch that are adaptable to any platform. You’ll go beyond basic chatbots, developing systems capable of semantic and sentiment analysis—with context-aware AI controllers at their core.

你将完整地学习如何设计具有多用户记忆保持功能的AI控制器架构，使系统能够适应各种用户和系统输入。在此基础上，你将使用Pinecone构建一个动态检索增强生成（RAG）系统，该系统旨在智能地组合指令场景。 

You’ll walk through the complete journey of designing an AI controller architecture with multi-user memory retention, enabling the system to adapt to diverse user and system inputs. Building on this foundation, you’ll architect a dynamic retrieval-augmented generation (RAG) system using Pinecone, designed to intelligently combine instruction scenarios. 

凭借强大的多模态功能——包括图像生成、语音交互和机器驱动推理——您将能够利用思维链编排扩展系统的智能，从而应对真实业务环境中跨领域的自动化挑战。此外，您还将能够轻松地将 OpenAI 的 LLM 和 DeepSeek-R1 等前沿模型集成到您的 AI 系统中，并确信即使在当今瞬息万变的 AI 生态系统中，系统也能保持稳定、可扩展且随时可用于生产环境。

With powerful multimodal capabilities—including image generation, voice interactions, and machine-driven reasoning—you’ll expand your system’s intelligence using chain-of-thought orchestration to tackle the cross-domain automation challenges that real business environments demand. You’ll also be fully equipped to integrate cutting-edge models such as OpenAI’s LLMs and DeepSeek-R1 into your AI system—confident that it will remain stable, scalable, and production-ready even in the turbulent pace of today’s AI ecosystem.

最终，您的生成式人工智能系统（GenAISys）将能够进行轨迹分析和人类移动预测，即使数据不完整也能胜任。它将为您的营销信息带来神经科学启发式的洞察，无缝集成到人类工作流程中，可视化复杂的交付和移动场景，并连接到实时外部数据——所有这些都集成在一个精美且面向投资者的界面中。

By the end, your generative AI system (GenAISys) will be capable of trajectory analysis and human mobility prediction, even when working with incomplete data. It will bring neuroscience-inspired insight to your marketing messages, integrate seamlessly into human workflows, visualize complex delivery and movement scenarios, and connect to live external data—all wrapped in a polished, investor-ready interface.

本书适合哪些读者？

Who this book is for

本书面向人工智能和机器学习工程师、软件架构师以及企业开发人员，旨在帮助他们从零开始构建一个全面的企业级人工智能系统（GenAISys）。本书尤其适合那些对构建人工智能代理、创建高级编排系统以及利用人工智能实现市场营销、生产和物流自动化感兴趣的人士。此外，希望构建可扩展的人工智能驱动系统的软件架构师和企业开发人员也能从本书中获益匪浅。本书不要求读者具备任何超级智能方面的经验，但建议读者熟悉人工智能概念。

This book is for AI and machine learning engineers, software architects, and enterprise developers seeking to architect and build a comprehensive GenAISys from scratch for enterprise applications. It will particularly benefit those interested in building AI agents, creating advanced orchestration systems, and leveraging AI for automation in marketing, production, and logistics. Software architects and enterprise developers looking to build scalable AI-driven systems will also find immense value in this guide. No prior superintelligence experience is necessary, but familiarity with AI concepts is recommended.

本书涵盖的内容

What this book covers

第一章“定义可用于业务的生成式人工智能系统”阐述了如何设计强大且达到 ChatGPT 级别的、专为商业用途量身定制的人工智能系统，该系统融合了人工智能控制器、代理、情境感知、高级记忆保持和战略性的人机协作。您将探索如何超越基本的模型集成，构建能够跨行业带来实际业务成果的人工智能解决方案，并成为一名能够适应任何环境的架构师。

Chapter 1, Defining a Business-Ready Generative AI System, explains how to design robust, ChatGPT-level AI systems tailored for business use, incorporating AI controllers, agents, contextual awareness, advanced memory retention, and strategic human collaboration. You will explore how to go beyond basic model integrations to build AI solutions that deliver real-world business results across industries and become an architect who can adapt to any environment.

第二章“构建生成式AI控制器”深入探讨了自适应AI控制器的实践开发，将对话代理和编排器相结合。您将熟练掌握如何构建一个能够动态响应用户输入、利用高级内存管理并编排情感和语义分析等任务的GenAISys系统，这些任务对于现实世界的数据密集型应用至关重要。

Chapter 2, Building the Generative AI Controller, dives into hands-on development of adaptive AI controllers, combining conversational agents and orchestrators. You’ll become proficient in building a GenAISys that dynamically responds to user input, leverages advanced memory management, and orchestrates tasks such as sentiment and semantic analysis, which are essential for real-world, data-intensive applications.

第三章“将动态 RAG 集成到 GenAISys 中”将教您如何使用 Pinecone 构建可扩展的动态 RAG 系统，有效地结合教学场景和传统数据。您将学习如何构建适应性强的生成式 AI 解决方案，从而能够快速响应现实世界的业务中断和特定领域的挑战。

Chapter 3, Integrating Dynamic RAG into the GenAISys, teaches you how to architect a scalable, dynamic RAG system using Pinecone, effectively combining instruction scenarios and classical data. You will discover how to build adaptable generative AI solutions capable of responding rapidly to real-world business disruptions and domain-specific challenges.

第四章“构建AI控制器编排接口”展示了如何构建一个协作式、事件驱动的生成式AI接口，旨在快速响应实际业务需求。我们将创建一个实用的多用户对话式AI，它可以无缝集成到人类工作流程中，并在关键场景下增强决策能力。

Chapter 4, Building the AI Controller Orchestration Interface, shows how to build a collaborative, event-driven generative AI interface designed for rapid, real-world business responses. We’ll create a practical, multi-user conversational AI that integrates seamlessly into human workflows, enhancing decision-making during critical scenarios.

第五章“利用思维链实现多模态、多功能推理”利用 OpenAI 强大的多模态功能（包括图像生成、语音交互和机器驱动推理）增强了我们的 GenAISys 系统。我们将通过思维链编排扩展系统的智能，从而实现针对复杂跨领域业务场景的智能自动化。

Chapter 5, Adding Multimodal, Multifunctional Reasoning with Chain of Thought, enhances our GenAISys with OpenAI’s powerful multimodal capabilities, including image generation, voice interactions, and machine-driven reasoning. We’ll expand our system’s intelligence using chain-of-thought orchestration—enabling smart automation tailored to complex, cross-domain business scenarios.

第六章“推理型电子营销人工智能代理”利用人工智能驱动的记忆分析功能，打造令消费者印象深刻的营销信息。我们将构建一个消费者记忆代理，它能够智能分析评论和情绪，生成由多模态推理增强的个性化营销内容——将神经科学的洞见直接引入我们的GenAISys系统。

Chapter 6, Reasoning E-Marketing AI Agents, harnesses the power of AI-driven memory analysis to create marketing messages customers remember. We’ll build a consumer memory agent that intelligently analyzes reviews and emotions, producing personalized marketing content enhanced by multimodal reasoning—bringing neuroscience insights directly into our GenAISys.

第七章“利用 DeepSeek 增强 GenAISys”探讨了如何在不牺牲稳定性的前提下应对人工智能的快速发展。您将学习如何利用灵活的处理器选择机制，将 DeepSeek-R1 等前沿模型战略性地集成到 GenAISys 中，从而使我们的系统能够在快速变化的市场中保持适应性、可扩展性和生产就绪性。

Chapter 7, Enhancing the GenAISys with DeepSeek, navigates the rapid evolution of AI without compromising stability. You will learn how to strategically integrate cutting-edge models such as DeepSeek-R1 into our GenAISys, using a flexible handler selection mechanism—enabling our system to remain adaptable, scalable, and production-ready in a fast-changing market.

第八章“ GenAISys轨迹模拟与预测”将先进的AI驱动轨迹分析引入GenAISys，即使在数据不完整的情况下也能精准预测人员移动和货物配送。我们将构建一个直观的流程，利用LLM（线性线性模型）模拟、分析和可视化复杂的配送和移动场景，将空间数据转化为可执行的洞察。

Chapter 8, GenAISys for Trajectory Simulation and Prediction, brings advanced AI-driven trajectory analysis into our GenAISys to precisely predict human mobility and deliveries, even with incomplete data. We’ll build an intuitive pipeline that leverages LLMs to simulate, analyze, and visualize complex delivery and movement scenarios, transforming spatial data into actionable insights.

第九章“利用数据安全和审核功能升级 GenAISys 以提升客户服务”介绍了如何通过集成实时天气信息、旅行信息、强大的审核工具和高级安全功能，将 GenAISys 安全地连接到真实世界数据。您将了解如何安全地将人工智能的功能扩展到内部数据之外，从而实现个性化营销、动态活动推荐和实时客户互动。

Chapter 9, Upgrading the GenAISys with Data Security and Moderation for Customer Service, connects our GenAISys securely to real-world data by integrating live weather information, travel information, robust moderation tools, and advanced security features. You will discover how to safely extend our AI’s capabilities beyond internal data, enabling personalized marketing, dynamic activity recommendations, and real-time customer interactions.

第十章“展示您的商业化生成式人工智能系统”将向您展示如何将您的 GenAISys 概念验证转化为引人入胜、可供投资者参考的展示方案。我们将学习如何通过清晰的信息传递、实用的演示和完善的用户界面有效地展示我们的人工智能系统，从而吸引观众的注意力，展现其价值，并证明其已做好在竞争激烈的人工智能市场中扩展规模的准备。

Chapter 10, Presenting Your Business-Ready Generative AI System, will show you how to turn your GenAISys proof of concept into a compelling, investor-ready showcase. We’ll learn how to effectively present our AI system with clear messaging, practical demos, and a polished user interface, capturing audience attention, demonstrating value, and proving readiness to scale in a crowded AI marketplace.

为了充分利用这本书

To get the most out of this book

您无需成为人工智能专家即可从本指南中受益，只需熟悉人工智能和编程的基础知识即可。如果您使用过 Python 或探索过 ChatGPT 等语言学习模型 (LLM)，您会感觉非常熟悉。

You don’t need to be an AI expert to benefit from this guide, just some familiarity with the basics of artificial intelligence and programming. If you’ve worked with Python or explored LLMs like ChatGPT, you’ll feel right at home.

本书以清晰易懂、循序渐进的方式介绍了人工智能代理编排、记忆保留和红绿灯等概念。无论您是开发人员、工程师还是对技术感兴趣的人士，都能找到旨在支持实际应用的工具、代码和解释。

This book introduces concepts like AI agent orchestration, memory retention, and RAG in clear, hands-on steps. Whether you’re a developer, engineer, or curious technologist, you’ll find tools, code, and explanations designed to support real-world applications.

不需要深厚的数学或理论背景，只需要渴望构建能够解决业务问题并在生产环境中扩展的有意义的人工智能系统。

No deep math or theoretical background is required, only a desire to build meaningful AI systems that solve business problems and scale in production environments.

代码可在 Google Colab 笔记本中使用，并可自动安装，或者您可以下载代码到本地。

The code is available in Google Colab notebooks with automated installations or you can download the code locally.

下载示例代码文件

Download the example code files

本书的代码包托管在 GitHub 上，地址为https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems。我们丰富的图书和视频库中还有其他代码包，地址为https://github.com/PacktPublishing。欢迎查看！

The code bundle for the book is hosted on GitHub at https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing. Check them out!

下载彩色图片

Download the color images

我们还提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图像。您可以从这里下载：https://packt.link/gbp/9781837020690。

We also provide a PDF file that has color images of the screenshots/diagrams used in this book. You can download it here: https://packt.link/gbp/9781837020690.

惯例

Conventions used

本书中使用了多种文本惯例。

There are a number of text conventions used throughout this book.

CodeInText：用于指示文本中的代码词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入以及 Twitter/X 用户名。例如：“接下来，我们将整合instruct_selector到现有界面布局中（VBox）。”

CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter/X handles. For example: “Next, we incorporate instruct_selector into the existing interface layout (VBox).”

一段代码块的设置如下：

A block of code is set as follows:

# Ensure 'Instructions' exists in the memory_selector options
instruct_selector = Dropdown(
    options=["None","Analysis", "Generation"],
    value="None",  # Ensure default active_memory is in the options
    description='Reasoning:',
    layout=Layout(width='50%')
)

任何命令行输入或输出都按以下格式编写：

Any command-line input or output is written as follows:

Response: The dialog begins by explaining the formation of Hawaii's volcanic islands as the Pacific Plate moves over a stationary hotspot, leading to active volcanoes like Kilauea….

粗体：表示屏幕上出现的新术语、重要词语或单词。例如，菜单或对话框中的文字会以这种方式显示。例如：“用户随后重新输入句子，但这次勾选了‘生成’和‘文件’选项，以便显示用该文本生成的图像。”

Bold: Indicates a new term, an important word, or words that you see on the screen. For instance, words in menus or dialog boxes appear in the text like this. For example: “The user then reenters the sentence, but this time with the Generation option and the Files option checked, so that the image generated with the text will be displayed.”

联系我们

Get in touch

我们非常欢迎读者的反馈意见。

Feedback from our readers is always welcome.

一般反馈：如果您对本书的任何方面有疑问或有任何一般性反馈，请发送电子邮件至[电子邮件地址]customercare@packt.com 并在邮件主题中提及本书的标题。

General feedback: If you have questions about any aspect of this book or have any general feedback, please email us at customercare@packt.com and mention the book’s title in the subject of your message.

勘误：尽管我们已尽一切努力确保内容的准确性，但错误在所难免。如果您在本书中发现任何错误，请告知我们，我们将不胜感激。请访问http://www.packt.com/submit-errata，点击“提交勘误”，并填写表格。

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you reported this to us. Please visit http://www.packt.com/submit-errata, click Submit Errata, and fill in the form.

盗版：如果您在互联网上发现任何形式的非法复制品，请告知我们其位置地址或网站名称。请copyright@packt.com通过以下方式联系我们，并提供相关链接。

Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at copyright@packt.com with a link to the material.

如果您有兴趣成为一名作家：如果您在某个主题方面拥有专业知识，并且有兴趣撰写或参与撰写书籍，请访问http://authors.packt.com/。

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit http://authors.packt.com/.

分享你的想法

Share your thoughts

读完《构建可用于商业用途的生成式人工智能系统》后，我们非常希望听到您的想法！请点击此处直接前往本书的亚马逊评论页面，分享您的反馈。

Once you’ve read Building Business-Ready Generative AI Systems, we’d love to hear your thoughts! Please click here to go straight to the Amazon review page for this book and share your feedback.

您的评价对我们和科技界都非常重要，它将帮助我们确保提供高质量的内容。

Your review is important to us and the tech community and will help us make sure we’re delivering excellent quality content.

加入我们的 Discord 和 Reddit 空间

Join our Discord and Reddit space

你并非唯一一个在应对碎片化工具、频繁更新和不明确的最佳实践的人。加入我们不断壮大的专业人士社区，交流那些未被写入文档的真知灼见。

You’re not the only one navigating fragmented tools, constant updates, and unclear best practices. Join a growing community of professionals exchanging insights that don’t make it into documentation.

购买本书即可享受专属福利——以下是如何解锁这些福利的方法

Your Book Comes with Exclusive Perks – Here’s How to Unlock Them

立即解锁本书的专属权益 Unlock this book’s exclusive benefits now 扫描此二维码或访问packtpub.com/unlock，然后按书名搜索本书。请确保版本正确。 Scan this QR code or go to packtpub.com/unlock, then search this book by name. Ensure it’s the correct edition.
注意：开始之前请准备好您的采购发票。 Note: Keep your purchase invoice ready before you start.

使用我们的新一代阅读器，获得更佳的阅读体验：

Enhanced reading experience with our Next-gen Reader:

多设备进度同步：通过无缝进度同步，从任何设备学习。

Multi-device progress sync: Learn from any device with seamless progress sync.

重点标记和笔记：将阅读转化为持久的知识。

Highlighting and notetaking: Turn your reading into lasting knowledge.

书签功能：随时回顾您最重要的学习内容。

Bookmarking: Revisit your most important learnings anytime.

深色模式：切换到深色或棕褐色模式，以最小的眼睛疲劳集中注意力。

Dark mode: Focus with minimal eye strain by switching to dark or sepia mode.

使用我们的人工智能助手（测试版）更智能地学习：

Learn smarter using our AI assistant (Beta):

概括：概括关键部分或整个章节。

Summarize it: Summarize key sections or an entire chapter.

AI 代码解释器：在新一代 Packt Reader 中，点击每个代码块上方的“解释”按钮，即可获得 AI 驱动的代码解释。

AI code explainers: In the next-gen Packt Reader, click the Explain button above each code block for AI-powered code explanations.

随时随地学习：

Learn anytime, anywhere:

使用无 DRM 保护的 PDF 和 ePub 版本离线访问您的内容——与您喜爱的电子阅读器兼容。

Access your content offline with DRM-free PDF and ePub versions—compatible with your favorite e-readers.

解锁本书专属福利

Unlock Your Book’s Exclusive Benefits

您购买本书即可享受以下专属权益：

Your copy of this book comes with the following exclusive benefits:

新一代 Packt 阅读器

Next-gen Packt Reader

人工智能助手（测试版）

AI assistant (beta)

无DRM保护的PDF/ePub下载

DRM-free PDF/ePub downloads

如果您尚未解锁，请按照以下指南进行解锁。此过程只需几分钟，而且只需操作一次。

Use the following guide to unlock them if you haven’t already. The process takes just a few minutes and needs to be done only once.

如何通过三个简单的步骤解锁这些好处

How to unlock these benefits in three easy steps

步骤 1

Step 1

请准备好本书的购买发票，因为您将在步骤 3中用到它。如果您收到的是纸质发票，请用手机扫描并保存为 PDF、JPG 或 PNG 格式。

Keep your purchase invoice for this book ready, as you’ll need it in Step 3. If you received a physical invoice, scan it on your phone and have it ready as either a PDF, JPG, or PNG.

如需查找发票方面的更多帮助，请访问https://www.packtpub.com/unlock-benefits/help

For more help on finding your invoice, visit https://www.packtpub.com/unlock-benefits/help

步骤 2 Step 2 扫描此二维码或访问packtpub.com/unlock。 Scan this QR code or go to packtpub.com/unlock.
在打开的页面（如果您使用的是电脑，页面界面将类似于图 0.1）上，按书名搜索本书。请务必选择正确的版本。 On the page that opens (which will look similar to Figure 0.1 if you’re on desktop), search for this book by name. Make sure you select the correct edition. 图 0.1：Packt 解锁桌面版登录页面 Figure 0.1: Packt unlock landing page on desktop

步骤 3

Step 3

登录您的 Packt 账户或免费创建一个新账户。登录后，上传您的发票。发票格式可以是 PDF、PNG 或 JPG，大小不得超过 10 MB。按照屏幕上的其余说明完成操作。

Sign in to your Packt account or create a new one for free. Once you’re logged in, upload your invoice. It can be in PDF, PNG, or JPG format and must be no larger than 10 MB. Follow the rest of the instructions on the screen to complete the process.

需要帮助吗？ Need help? 如果您遇到问题需要帮助，请访问https://www.packtpub.com/unlock-benefits/help查看详细的常见问题解答，了解如何查找您的发票等信息。扫描以下二维码即可直接进入帮助页面： If you get stuck and need help, visit https://www.packtpub.com/unlock-benefits/help for a detailed FAQ on how to find your invoices and more. The following QR code will take you to the help page directly:

1

1

定义一个可用于商业用途的生成式人工智能系统

Defining a Business-Ready Generative AI System

在组织中部署生成式人工智能系统（GenAISys）并非仅仅通过API集成GPT、Grok、Llama或Gemini等独立模型。虽然这通常是起点，但我们常常误以为这就是终点。随着人工智能在各个领域的应用日益广泛，对人工智能的需求也与日俱增，这就要求我们部署更先进的人工智能系统，而不仅仅是集成预构建的模型。

Implementing a generative AI system (GenAISys) in an organization doesn’t stop at simply integrating a standalone model such as GPT, Grok, Llama, or Gemini via an API. While this is often a starting point, we often mistake it as the finish line. The rising demand for AI, as it expands across all domains, calls for the implementation of advanced AI systems that go beyond simply integrating a prebuilt model.

一个适用于企业的 GenAISys 系统不仅应该在组织内提供 ChatGPT 级别的功能，而且还应该远不止于此。其功能和特性必须包括自然语言理解（NLU）、通过记忆保持聊天会话中对话内容来实现上下文感知，以及诸如自主图像、音频和文档分析与生成等智能体功能。可以将生成式人工智能模型视为一个具有广泛功能的实体，其中包括作为智能体同事的人工智能代理。

A business-ready GenAISys should provide ChatGPT-grade functionality in an organization, but also go well beyond it. Its capabilities and features must include natural language understanding (NLU), contextual awareness through memory retention across dialogues in a chat session, and agentic functions such as autonomous image, audio, and document analysis and generation. Think of a generative AI model as an entity with a wide range of functions, including AI agents as agentic co-workers.

本章首先定义什么是可用于业务的生成式人工智能系统（GenAISys）。然后，我们将重点讨论生成式人工智能模型（例如 GPT-4o）的核心作用，该模型既可以协调任务，也可以执行任务。在此基础上，我们将为上下文感知和记忆保持奠定基础，并进行讨论。生成式人工智能的记忆分为四种类型：无记忆记忆、短期记忆、长期记忆和多会话记忆。我们还将定义一种新的检索增强生成（RAG）方法，该方法为数据检索引入了一个新维度：指令和智能体推理场景。通过将存储在向量存储中的指令添加到 RAG 中，我们可以检索指令并将其添加到提示中，从而将 RAG 提升到一个新的水平。同时，我们将研究生成式人工智能系统 (GenAISys) 的一个关键组成部分：人的角色。我们将了解人工智能系统在其整个生命周期中如何需要人类的专业知识。此外，我们将定义几个级别的实现方案，以便根据业务需求、可用预算和资源调整 GenAISys 的范围和规模。

We will begin the chapter by defining what a business-ready GenAISys is. From there, we’ll focus on the central role of a generative AI model, such as GPT-4o, that can both orchestrate and execute tasks. Building on that, we will lay the groundwork for contextual awareness and memory retention, discussing four types of generative AI memory: memoryless, short-term, long-term, and multiple sessions. We will also define a new approach to retrieval-augmented generation (RAG) that introduces an additional dimension to data retrieval: instruction and agentic reasoning scenarios. Adding instructions stored in a vector store takes RAG to another level by retrieving instructions that we can add to a prompt. In parallel, we will examine a critical component of a GenAISys: human roles. We will see how, throughout its life cycle, an AI system requires human expertise. Additionally, we will define several levels of implementation to adapt the scope and scale of a GenAISys, not only to business requirements but also to available budgets and resources.

最后，我们将阐述如何使用 OpenAI 的 LLM 和多模态 API 实现上下文感知和记忆保持。GenAISys 必须具备强大的记忆保持功能才能正常工作——没有记忆，就没有上下文；没有上下文，就无法实现可持续的生成。本书中，我们将根据具体任务创建用于无记忆、短期记忆、长期记忆和多会话记忆的模块。读完本章，您将掌握一个清晰的概念框架，了解如何构建一个可用于商业应用的 AI 系统，并获得构建 AI 控制器基础架构的实践经验。

Finally, we’ll illustrate how contextual awareness and memory retention can be implemented using OpenAI’s LLM and multimodal API. A GenAISys cannot work without solid memory retention functionality—without memory, there’s no context, and without context, there’s no sustainable generation. Throughout this book, we will create modules for memoryless, short-term, long-term, and multisession types depending on the task at hand. By the end of this chapter, you will have acquired a clear conceptual framework for what makes an AI system business-ready and practical experience in building the first bricks of an AI controller.

简而言之，本章涵盖以下主题：

In a nutshell, this chapter covers the following topics:

• 适用于企业的 GenAISys 的组成部分
• Components of a business-ready GenAISys
• AI控制器和代理功能（与模型无关）
• AI controllers and agentic functionality (model-agnostic)
• 混合型人类角色以及与人工智能的协作
• Hybrid human roles and collaboration with AI
• 商业机会和范围
• Business opportunities and scope
• 通过记忆保持来感知情境
• Contextual awareness through memory retention

我们首先来定义一下什么是可用于业务的 GenAISys。

Let’s begin by defining what a business-ready GenAISys is.

适用于企业的 GenAISys 的组成部分

Components of a business-ready GenAISys

可用于商业用途的 GenAISys 是一个模块化编排器，可将标准 AI 模型与……无缝集成多功能框架提供混合智能。通过将生成式人工智能与代理功能、RAG、机器学习( ML ) 和 Web相结合凭借搜索、非人工智能操作和多会话记忆系统等技术，我们能够为各种复杂任务提供可扩展且自适应的解决方案。以 ChatGPT 为例，人们常常将“ChatGPT”这个名称既指代生成式人工智能模型，也指代应用程序本身。然而，在聊天界面背后，ChatGPT 和 Gemini 等工具实际上是更大型系统（在线副驾驶）的一部分，这些系统由智能人工智能控制器完全集成和管理，旨在提供流畅的用户体验。

A business-ready GenAISys is a modular orchestrator that seamlessly integrates standard AI models with multifunctional frameworks to deliver hybrid intelligence. By combining generative AI with agentic functionality, RAG, machine learning (ML), web search, non-AI operations, and multiple-session memory systems, we are able to deliver scalable and adaptive solutions for diverse and complex tasks. Take ChatGPT, for example; people use the name “ChatGPT” interchangeably for the generative AI model as well as for the application itself. However, behind the chat interface, tools such as ChatGPT and Gemini are part of larger systems—online copilots—that are fully integrated and managed by intelligent AI controllers to provide a smooth user experience.

Tomczak (2024) 的论文使我们从将生成式人工智能模型视为一个整体，转向考虑复杂的 GenAISys 架构。他的论文使用“GenAISys”一词来描述这些更复杂的平台。本书旨在拓展 GenAISys 的视野，使其包含高级人工智能控制器功能以及在商业化生态系统中的人为角色。GenAISys 并不存在万能的架构。然而，在本节中，我们将定义实现 ChatGPT 级别功能所需的主要组件。这些组件包括生成式人工智能模型、记忆保持功能、模块化 RAG 以及多功能性。图 1.1展示了每个组件如何为 GenAISys 框架做出贡献：

It was Tomczak (2024) who took us from thinking of generative AI models as a collective entity to considering complex GenAISys architectures. His paper uses the term “GenAISys” to describe these more complex platforms. Our approach in this book will be to expand the horizon of a GenAISys to include advanced AI controller functionality and human roles in a business-ready ecosystem. There is no single silver-bullet architecture for a GenAISys. However, in this section, we’ll define the main components necessary to attain ChatGPT-level functionality. These include a generative AI model, memory retention functions, modular RAG, and multifunctional capabilities. How each component contributes to the GenAISys framework is illustrated in Figure 1.1:

图 1.1：GenAISys、AI 控制器和人类角色

Figure 1.1: GenAISys, the AI controller, and human roles

现在我们来定义一下构成 GenAISys 的 AI 控制器和人类角色的架构。

Let’s now define the architecture of the AI controllers and human roles that make up a GenAISys.

人工智能控制器

AI controllers

一个可用于商业用途的 GenAISys 的核心是一个AI 控制器，它可以激活自定义的 ChatGPT 级功能。基于输入上下文。与具有预定任务顺序的传统流程不同，AI 控制器没有固定的运行顺序，而是根据每个输入的具体上下文动态调整任务，例如网络搜索、图像分析和文本生成。这种基于上下文的智能体方法使 AI 控制器能够无缝协调各个组件，确保生成式人工智能模型高效、连贯地运行。

At the heart of a business-ready GenAISys is an AI controller that activates custom ChatGPT-level features based on the context of the input. Unlike traditional pipelines with predetermined task sequences, the AI controller operates without a fixed order, dynamically adapting tasks—such as web search, image analysis, and text generation—based on the specific context of each input. This agentic context-driven approach enables the AI controller to orchestrate various components seamlessly, ensuring effective and coherent performance of the generative AI model.

要利用定制的 ChatGPT 级 AI 控制器取得有效成果，需要付出大量努力。然而，回报是打造一类能够承受现实世界压力并产生切实业务成果的新型 AI 系统。一个强大的 AI 控制器生态系统可以支持多个领域的应用场景：客户支持自动化、销售线索生成、生产优化（服务和制造）、医疗保健响应支持、供应链优化，以及市场可能涉及的任何其他领域！因此，GenAISys 需要一个 AI 控制器来协调多个流程，例如上下文感知以理解提示的意图，以及记忆保持以支持跨会话的连续性。

A lot of work is required to achieve effective results with a custom ChatGPT-grade AI controller. However, the payoff is a new class of AI systems that can withstand real-world pressure and produce tangible business results. A solid AI controller ecosystem can support use cases across multiple domains: customer support automation, sales lead generation, production optimization (services and manufacturing), healthcare response support, supply chain optimization, and any other domain the market will take you! A GenAISys, thus, requires an AI controller to orchestrate multiple pipelines, such as contextual awareness to understand the intent of the prompt and memory retention to support continuity across sessions.

GenAISys 还必须定义人类角色，这些角色决定了可以访问哪些功能和数据。不过，在讨论人类角色之前，我们先来了解一下驱动 AI 控制器的关键组件。如图1.1所示，生成式 AI 模型、内存和模块化组件构成了系统的核心。RAG（红绿灯）和多功能性在实现灵活的、上下文驱动的编排方面都发挥着至关重要的作用。让我们探讨这些要素如何协同工作，构建一个可用于业务的 GenAISys。首先，我们将定义生成式 AI 模型的作用。

The GenAISys must also define human roles, which determine which functions and data can be accessed. Before we move on to human roles, however, let’s first break down the key components that power the AI controller. As shown in Figure 1.1, the generative AI model, memory, modular RAG, and multifunctional capabilities each play vital roles in enabling flexible, context-driven orchestration. Let’s explore how these elements work together to build a business-ready GenAISys. We will first define the role of the generative AI model.

生成式人工智能的模型无关方法

Model-agnostic approach to generative AI

构建可持续的GenAISys系统时，我们需要模型互换性——即模型更换的灵活性。根据需要导出底层模型。生成式人工智能模型应作为系统的一个组件，而不是作为系统本身。系统的核心是围绕这个框架构建。这样一来，如果我们的模型被弃用或需要更新，或者我们找到了性能更好的模型，我们就可以轻松地用更适合我们项目的模型替换它。

When we build a sustainable GenAISys, we need model interchangeability—the flexibility to swap out the underlying model as needed. A generative AI model should serve as a component within the system, not as the core that the system is built around. That way, if our model is deprecated or requires updating, or we simply find a better-performing one, we can simply replace it with another that better fits our project.

因此，生成式人工智能模型可以是 OpenAI 的 GPT、Google 的 Gemini、Meta 的 Llama、xAI 的 Grok，或者任何 Hugging Face 模型，只要它支持所需的任务即可。理想情况下，我们应该选择一个多用途、多模态的模型，该模型应涵盖文本、视觉和推理能力。Bommasani 等人 (2021) 对这类基础模型进行了全面的分析，其范围远超语言学习模型 (LLM)。

As such, the generative AI model can be OpenAI’s GPT, Google’s Gemini, Meta’s Llama, xAI’s Grok, or any Hugging Face model, as long as it supports the required tasks. Ideally, we should choose a multipurpose, multimodal model that encompasses text, vision, and reasoning abilities. Bommasani et al. (2021) provide a comprehensive analysis of such foundation models, whose scope reaches beyond LLMs.

如图 1.2所示，生成式 AI 模型具有两个主要功能：

A generative AI model has two main functions, as shown in Figure 1.2:

• 根据输入信息确定需要触发哪些任务，从而进行协调。此输入可以是用户提示或系统请求来自管道中的另一个功能。编排功能代理可以触发网络搜索、文档解析、图像生成、RAG、机器学习功能、非人工智能功能以及集成到 GenAISys 中的任何其他功能。
• Orchestrates by determining which tasks need to be triggered based on the input. This input can be a user prompt or a system request from another function in the pipeline. The orchestration function agent can trigger web search, document parsing, image generation, RAG, ML functions, non-AI functions, and any other function integrated into the GenAISys.
• 执行任务应乐团要求层或直接根据输入执行任务。例如，像查询美国首都这样的简单查询不一定需要复杂的功能。但是，文档分析请求可能需要多个功能（分块、嵌入、存储和检索）。
• Executes the tasks requested by the orchestration layer or executes a task directly based on the input. For example, a simple query such as requesting the capital of the US will not necessarily require complex functionality. However, a request for document analysis might require several functions (chunking, embedding, storing, and retrieving).

图 1.2：用于协调或执行任务的生成式 AI 模型

Figure 1.2: A generative AI model to orchestrate or execute tasks

请注意图 1.2 的一个独特之处。图中没有箭头指示输入、编排和执行组件的方向。与传统的硬编码线性流水线不同，灵活的 GenAISys 的组件是无序的。我们构建组件，然后让编排功能选择的自动化场景动态地对任务进行排序。

Notice that Figure 1.2 has a unique feature. There are no arrows directing the input, orchestration, and execution components. Unlike traditional hardcoded linear pipelines, a flexible GenAISys has its components unordered. We build the components and then let automated scenarios selected by the orchestration function order the tasks dynamically.

这种灵活性确保系统的能够适应各种各样的任务。我们将我们无法构建一个能够解决所有任务的系统，但我们可以构建一个能够满足公司内部各种任务需求的系统。以下两个示例工作流程说明了 GenAISys 如何根据相关角色动态地对任务进行排序：

This flexibility ensures the system’s adaptability to a wide range of tasks. We will not be able to build a system that solves every task, but we can build one that satisfies a wide range of tasks within a company. Here are two example workflows that illustrate how a GenAISys can dynamically sequence tasks based on the roles involved:

• 可以配置人类角色，以便在某些情况下，用户输入会执行简单的 API 调用以提供直接的响应，例如请求某个国家的首都。在这种情况下，生成式 AI 模型会直接执行请求。
• Human roles can be configured so that, in some cases, the user input executes a simple API call to provide a straightforward response, such as requesting the capital of a country. In this case, the generative AI model executes a request directly.
• 系统角色可以动态配置，以协调一系列指令，例如先搜索网络，然后汇总网页内容。在这种情况下，系统会经过一个协调过程来生成输出。
• System roles can be configured dynamically to orchestrate a set of instructions, such as searching the web first and then summarizing the web page. In this case, the system goes through an orchestration process to produce an output.

可能性无穷无尽；然而，所有场景都将依赖于内存来确保一致且符合上下文的行为。接下来我们来看一下内存。

The possibilities are unlimited; however, all the scenarios will rely on the memory to ensure consistent, context-aware behavior. Let’s look at memory next.

构建 GenAISys 的内存

Building the memory of a GenAISys

先进的诸如 OpenAI 的 GPT、Meta 的 Llama、xAI 的 Grok、Google 的 Gemini 以及许多 Hugging Face 的变体等生成式 AI 模型，无论其具体版本或性能水平如何，都是上下文驱动的。您需要根据项目需求选择模型，但基本原则依然很简单：

Advanced generative AI models such as OpenAI’s GPT, Meta’s Llama, xAI’s Grok, Google’s Gemini, and many Hugging Face variants are context-driven regardless of their specific version or performance level. You will choose the model based on your project, but the basic rule remains simple:

无上下文 => 无有意义的生成

No-context => No meaningful generation

当我们使用 ChatGPT 或任何其他辅助工具时，无需担心上下文记忆的问题，因为它们会自动处理。我们只需开始对话，然后根据收到的回复水平调整提示语，一切都会顺利进行。然而，当我们开发一个带有生成式 AI API 的系统时，情况就不同了。我们必须从零开始，明确地构建情境感知和记忆保持能力。

When we use ChatGPT or any other copilot, we have nothing to worry about as contextual memory is handled for us. We just start a dialogue, and things run smoothly as we adapt our prompt to the level of responses we are obtaining. However, when we develop a system with a generative AI API from scratch, we have to explicitly build contextual awareness and memory retention.

在众多可通过 API 实现的记忆保持策略中，有四种方法脱颖而出：

Four approaches stand out among the wide range of possible memory retention strategies with an API:

• 无状态、无内存会话：向 API 发送请求，并返回响应。不具备记忆保持功能。
• Stateless and memoryless session: A request is sent to the API, and a response is returned with no memory retention functionality.
• 短期记忆会话：请求和响应之间的交换信息在会话期间存储在内存中，但会话结束后不会再存储。
• Short-term memory session: The exchanges between the requests and responses are stored in memory during the session but not beyond.
• 多次会话的长期记忆：请求与会话之间的交流即使会话结束后，回答也会存储在内存中并被记住。
• Long-term memory of multiple sessions: The exchanges between the requests and responses are stored in memory and memorized even after the session ends.
• 多个跨主题会议的长期记忆：此功能将长期记忆联系起来允许多个会话之间相互记忆。每个会话都被分配一个角色：系统角色或多个用户角色。此功能在 ChatGPT 等平台中并非标准配置，但对于组织内部的工作流管理至关重要。
• Long-term memory of multiple cross-topic sessions: This feature links the long-term memory of multiple sessions to other sessions. Each session is assigned a role: a system or multiple users. This feature is not standard in platforms such as ChatGPT but is essential for workflow management within organizations.

图 1.3总结了这四种内存架构。我们将在下一节“上下文感知和内存保持”中，使用 GPT-4o 在 Python 中演示每种配置。

Figure 1.3 sums up these four memory architectures. We’ll demonstrate each configuration in Python using GPT-4o in the upcoming section, Contextual awareness and memory retention.

图 1.3：四种不同的 GenAISys 内存配置

Figure 1.3: Four different GenAISys memory configurations

这四人内存类型是开发 GenAISys 的起点，可以根据需要进行扩展。然而，实际应用中通常需要额外的功能，包括以下方面：

These four memory types serve as a starting point that can be expanded as necessary when developing a GenAISys. However, practical implementations often require additional functionality, including the following:

• 我们将通过定义用户角色来定义可以访问会话历史记录或多个主题会话集的用户或用户组。这将使我们超越 ChatGPT 级别的平台。我们将在第二章“构建生成式 AI 控制器”中介绍这方面内容。
• Human roles to define users or groups of users that can access session history or sets of sessions on multiple topics. This will take us beyond ChatGPT-level platforms. We will introduce this aspect in Chapter 2, Building the Generative AI Controller.
• 存储策略用于定义我们需要存储的内容和需要丢弃的内容。我们将介绍存储策略，并在第三章“将动态 RAG 集成到 GenAISys 中”中，通过 Pinecone 向量存储进一步阐述这一概念。
• Storage strategies to define what we need to store and what we need to discard. We will introduce storage strategies and take this concept further with a Pinecone vector store in Chapter 3, Integrating Dynamic RAG into the GenAISys.

生成模型中，记忆的两大主要类别之间存在着本质区别：

There are native distinctions between two key categories of memorization in generative models:

• 语义记忆，包含诸如硬科学之类的事实
• Semantic memory, which contains facts such as hard science
• 情景记忆，包含带有时间戳的个人记忆，例如个人事件和商务会议
• Episodic memory, which contains personal timestamped memories such as personal events in time and business meetings

我们可以看到，构建 GenAISys 的记忆系统需要精心设计和周密开发，以实现 ChatGPT 级别的记忆功能以及其他记忆配置，例如长期跨主题会话。然而，这种高级记忆系统的最终目标是增强模型的上下文感知能力。虽然像 GPT-4o 这样的生成式 AI 模型已经内置了上下文感知能力，但为了扩展我们正在构建的 GenAISys 这类上下文驱动系统的功能，我们需要集成高级的 RAG 功能。

We can see that building a GenAISys’s memory requires careful design and deliberate development to implement ChatGPT-grade memory and additional memory configurations, such as long-term, cross-topic sessions. The ultimate goal, however, of this advanced memory system is to enhance the model’s contextual awareness. While generative AI models such as GPT-4o have inbuilt contextual awareness, to expand the scope of a context-driven system such as the GenAISys we’re building, we need to integrate advanced RAG functionality.

RAG 作为主动的多功能协调者

RAG as an agentic multifunction co-orchestrator

在本节中，我们将解释使用 RAG 的动机GenAISys的三大核心功能：

In this section, we explain the motivations for using RAG for three core functions within a GenAISys:

• 知识检索：检索有针对性的、细致入微的信息
• Knowledge retrieval: Retrieving targeted, nuanced information
• 上下文窗口优化：工程优化提示
• Context window optimization: Engineering optimized prompts
• 多功能能力的智能体编排：动态触发功能
• Agentic orchestration of multifunctional capabilities: Triggering functions dynamically

让我们从知识检索开始。

Let’s begin with knowledge retrieval.

1. 知识检索

1. Knowledge retrieval

生成式人工智能模型在揭示它们所学习到的参数化知识方面表现出色，这方面……这些知识嵌入在模型的权重中。这些知识在训练过程中学习并嵌入到 GPT、Llama、Grok 和 Gemini 等模型中。然而，当不再向模型输入新数据时，这些知识就会在截止日期后停止更新。此时，为了更新或补充这些知识，我们有两种选择：

Generative AI models excel when it comes to revealing parametric knowledge that they have learned, which is embedded in their weights. This knowledge is learned during training and embedded in models such as GPT, Llama, Grok, and Gemini. However, that knowledge stops at the cutoff date when no additional data is fed to the model. At that point, to update or supplement it, we have two options:

• 隐性知识：对模型进行微调，将更多已训练的知识添加到其权重中（参数化）。如果您处理的是每日变化的动态数据，例如天气预报、新闻推送或社交媒体消息，则此过程可能具有挑战性。如果微调过程对您的数据效果不佳，则还会带来成本和风险。
• Implicit knowledge: Fine-tune the model so that more trained knowledge is added to its weights (parametric). This process can be challenging if you are working with dynamic data that changes daily, such as weather forecasts, newsfeeds, or social media messages. It also comes with costs and risks if the fine-tuning process doesn’t work that well for your data.
• 显式知识：将数据存储在文件中或嵌入到向量存储中。这样，知识将结构化、可访问、可追溯且可更新。之后，我们可以使用高级查询来检索信息。
• Explicit knowledge: Store the data in files or embed data in vector stores. The knowledge will then be structured, accessible, traceable, and updated. We can then retrieve the information with advanced queries.

需要注意的是，静态的隐性知识如果没有动态的显性知识，就无法有效扩展。更多内容将在后续章节中讨论。

It’s important to note here that static implicit knowledge cannot scale effectively without dynamic explicit knowledge. More on that in the upcoming chapters.

2. 上下文窗口优化

2. Context window optimization

生成式人工智能模型正在扩展上下文窗口的边界。例如，截至撰写本文时，支持的上下文长度如下：

Generative AI models are expanding the boundaries of context windows. For example, at the time of writing, the following are the supported context lengths:

• 羊驼4侦察兵：1000万代币
• Llama 4 Scout: 10 million tokens
• Gemini 2.0 Pro 实验版：200 万代币
• Gemini 2.0 Pro Experimental: 2 million tokens
• 克劳德 3.7 十四行诗：200,000 个代币
• Claude 3.7 Sonnet: 200,000 tokens
• GPT-4o：128,000 个词元
• GPT-4o: 128,000 tokens

虽然这些大型上下文窗口令人印象深刻，但它们在令牌成本和计算方面会非常昂贵。此外，主要问题在于，当上下文过大时，其精度会降低。而且，我们并不需要最大的上下文窗口，而只需要最适合我们项目的那个。因此，如果需要优化项目，就可以考虑实现 RAG（红绿蓝宝石算法）。

While impressive, these large context windows can be expensive in terms of token costs and compute. Furthermore, the main issue is that their precision diminishes when the context becomes too large. Also, we don’t need the largest context window but only the one that best fits our project. This can justify implementing RAG if necessary to optimize a project.

RAG 的分块过程将大型内容拆分成更细致的词元组。当我们嵌入这些分块时，它们就变成了向量，可以存储并从向量存储库中高效检索。这种方法确保我们只使用每个任务最相关的上下文，从而最大限度地减少令牌使用和最大化响应质量。因此，我们可以依赖生成式人工智能能力来处理参数化的隐式知识，并依赖 RAG 来处理向量存储中大量的显式非参数数据。我们可以进一步扩展 RAG，并将其用作协调器。

The chunking process of RAG splits large content into more nuanced groups of tokens. When we embed these chunks, they become vectors that can be stored and efficiently retrieved from vector stores. This approach ensures we use only the most relevant context per task, minimizing token usage and maximizing response quality. Thus, we can rely on generative AI capabilities for parametric implicit knowledge and RAG for large volumes of explicit non-parametric data in vector stores. We can take RAG further and use the method as an orchestrator.

3. 多功能能力的代理协调者

3. Agentic orchestrator of multifunctional capabilities

AI控制器通过生成式AI模型与RAG连接。RAG用于增强……模型的输入包含一系列灵活的指令。乍一看，使用 RAG 来检索指令似乎有悖常理——但仔细想想。如果我们把指令存储为向量，并针对特定任务检索最佳指令集，就能获得一种快速、灵活的方式来实现智能体功能，生成有效的结果，并且避免每次更改指令策略以适应模型行为时都需要对模型进行微调。

The AI controller bridges with RAG through the generative AI model. RAG is used to augment the model’s input with a flexible range of instructions. Now, using RAG to retrieve instructions might seem counterintuitive at first—but think about it. If we store instructions as vectors and retrieve the best set for a task, we get a fast, adaptable way to enable agentic functionality, generate effective results, and avoid the need to fine-tune the model every time we change our instruction strategies for how we want it to behave.

这些指令充当优化的提示，针对当前任务量身定制。从这个意义上讲，RAG 成为 AI 系统编排层的一部分。像 Pinecone 这样的向量存储可以存储和返回这些功能信息，如图1.4所示：

These instructions act as optimized prompts, tailored to the task at hand. In this sense, RAG becomes part of the orchestration layer of the AI system. A vector store such as Pinecone can store and return this functional information, as illustrated in Figure 1.4:

图 1.4：RAG 编排功能

Figure 1.4: RAG orchestration functionality

这些场景的协调安排通过以下步骤实现：

The orchestration of these scenarios is performed through the following:

• 场景检索：AI控制器将从向量数据库（例如Pinecone）接收结构化指令（场景），这些指令会根据用户的查询进行调整。
• Scenario retrieval: The AI controller will receive structure instructions (scenarios) from a vector database, such as Pinecone, adapted to the user’s query
• 动态任务激活：每个场景都指定一系列任务，例如网页搜索、机器学习算法、标准 SQL 查询或我们需要的任何功能。
• Dynamic task activation: Each scenario specifies a series of tasks, such as web search, ML algorithms, standard SQL queries, or any function we need

添加GenAISys 的经典功能和机器学习功能极大地增强了其性能。GenAISys 的模块化架构使这种多功能方法得以有效应用，例如以下用例：

Adding classical functions and ML functionality to the GenAISys enhances its capabilities dramatically. The modular architecture of a GenAISys makes this multifunctional approach effective, as in the following use cases:

• 利用网络搜索进行实时搜索，以增强输入
• Web search to perform real-time searches to augment inputs
• 文档分析，用于处理文档并填充矢量存储库
• Document analysis to process documents and populate the vector store
• 从矢量存储库中检索已处理文档的部分内容，进行文档搜索。
• Document search to retrieve parts of the processed documents from the vector store
• 机器学习使用K-means 聚类( KMC ) 对数据进行分组以及用于相似性搜索的k近邻（KNN）算法
• ML such as K-means clustering (KMC) to group data and k-nearest neighbors (KNN) for similarity searches
• 用于对结构化数据集执行基于规则的检索的 SQL 查询
• SQL queries to execute rule-based retrieval on structured datasets
• 项目或工作流程所需的任何其他功能
• Any other function required for your project or workflow

RAG 仍然是 GenAISys 的关键组成部分，我们将在第 3 章“将动态 RAG 集成到 GenAISys 中”中将其构建到我们的 GenAISys 中。在第 3 章“将动态 RAG 集成到 GenAISys 中”中，我们还将通过多功能特性增强系统。

RAG remains a critical component of a GenAISys, which we will build into our GenAISys in Chapter 3, Integrating Dynamic RAG into the GenAISys. In Chapter 3, Integrating Dynamic RAG into the GenAISys, we will also enhance the system with multifunctional features.

接下来我们将讨论构成任何 GenAISys 支柱的人员角色。

We’ll now move on to the human roles, which form the backbone of any GenAISys.

人类角色

Human roles

与普遍认知相反，GenAISys（例如 ChatGPT 平台）的成功部署和运行在其整个生命周期中都高度依赖于人的参与。虽然这些工具看似能够处理复杂问题。这些任务看似毫不费力地完成，但其背后却有多层的人力专业知识、监督和协调，才使得它们的顺利运行成为可能。

Contrary to popular belief, the successful deployment and operation of a GenAISys—such as the ChatGPT platform—relies heavily on human involvement throughout its entire life cycle. While these tools may seem to handle complex tasks effortlessly, behind the scenes are multiple layers of human expertise, oversight, and coordination that make their smooth operation possible.

软件专业人员首先必须设计架构，处理海量数据集，并在配备尖端计算资源的价值百万美元的服务器上对系统进行微调。部署完成后，需要庞大的团队监控、验证和解读系统输出，并根据错误、新兴技术和监管变化不断调整系统。此外，在组织内部部署这些系统时——无论是在企业内部网、面向公众的网站、研究环境还是学习管理系统中——都需要跨多个领域的跨职能协调。

Software professionals must first design the architecture, process massive datasets, and fine-tune the system on million-dollar servers equipped with cutting-edge compute resources. After deployment, large teams are required to monitor, validate, and interpret system outputs—continuously adapting them in response to errors, emerging technologies, and regulatory changes. On top of that, when it comes to deploying these systems within organizations—whether inside corporate intranets, public-facing websites, research environments, or learning management systems—it takes cross-functional coordination efforts across multiple domains.

这些任务需要高水平的专业知识和合格的团队。因此，人类不仅不可替代，而且至关重要！他们是人工智能系统的架构师、监督者、管理者和守护者，负责创建和维护这些系统。

These tasks require high levels of expertise and qualified teams. Humans are, therefore, not just irreplaceable; they are critical! They are architects, supervisors, curators, and guardians of the AI systems they create and maintain.

GenAISys实施和治理团队

GenAISys implementation and governance teams

实施 GenAISys 需要技术技能和团队合作才能获得最终用户的支持。AI控制器设计、用户角色和期望之间的协作挑战。对于任何认为部署现实世界的AI会面临挑战的人来说，这都是一个值得探讨的问题。系统并非仅仅是获取模型（例如最新的 GPT、Llama 或 Gemini）那么简单，仔细审视所需的资源才能揭示真正的挑战。人工智能系统的开发、部署和维护可能需要大量的人力资源。当然，并非每个组织都需要所有这些角色，但我们必须认识到其中涉及的各种技能，例如以下这些：

Implementing a GenAISys requires technical skills and teamwork to gain the support of end users. It’s a collaborative challenge between AI controller design, user roles, and expectations. To anyone who thinks that deploying a real-world AI system is just about getting access to a model—such as the latest GPT, Llama, or Gemini—a close look at the resources required will reveal the true challenges. A massive number of human resources might be involved in the development, deployment, and maintenance of an AI system. Of course, not every organization will need all of these roles, but we must recognize the range of skills involved, such as the following:

• 项目经理（PM）
• Project manager (PM)
• 产品经理
• Product manager
• 项目经理
• Program manager
• 机器学习工程师（MLE）/数据科学家
• ML engineer (MLE)/data scientist
• 软件开发人员/后端工程师（BE）
• Software developer/backend engineer (BE)
• 云工程师（CE）
• Cloud engineer (CE)
• 数据工程师（DE）和隐私经理
• Data engineer (DE) and privacy manager
• UI/UX设计师
• UI/UX designer
• 合规与监管官员
• Compliance and regulatory officer
• 法律顾问
• Legal counsel
• 安全工程师（SE）和保安
• Security engineer (SE) and security officer
• 每个特定领域的部署都有相应的领域专家
• Subject-matter experts for each domain-specific deployment
• 质量保证工程师（QAE）和测试员
• Quality assurance engineer (QAE) and tester
• 技术文档编写员
• Technical documentation writer
• 系统维护和支持技术员
• System maintenance and support technician
• 用户支持
• User support
• 教练
• Trainer

这些只是示例——足以说明构建和运行一个完整的GenAISys系统涉及多少不同的角色。图1.5显示，GenAISys系统的设计和实施是一个持续的过程，每个阶段都需要人力资源。

These are just examples—just enough to show how many different roles are involved in building and operating a full-scale GenAISys. Figure 1.5 shows that designing and implementing a GenAISys is a continual process, where human resources are needed at every stage.

图 1.5：GenAISys 生命周期

Figure 1.5: A GenAISys life cycle

我们可以请注意，GenAISys 的生命周期是一个永无止境的过程：

We can see that a GenAISys life cycle is a never-ending process:

• 业务需求会随着市场限制而不断演变。
• Business requirements will continually evolve with market constraints
• GenAISys的设计必须随着每一次业务变化而调整。
• GenAISys design will have to adapt with each business shift
• 人工智能控制器规范必须适应技术进步。
• AI controller specifications must adapt to technological progress
• 实施方案必须适应不断变化的业务规范。
• Implementation must adapt to ever-changing business specifications
• 用户反馈将推动持续改进
• User feedback will drive continual improvement

现实世界人工智能高度依赖人类的能力——那种人工智能自身无法复制的对上下文和技术的理解。人工智能可以有效地自动化各种任务，但只有人类才能提供深刻的洞察力，使这些系统与真正的业务目标保持一致。

Real-world AI relies heavily on human abilities—the kind of contextual and technical understanding that AI alone cannot replicate. AI can automate a wide range of tasks effectively. But it’s humans who bring the deep insight needed to align those systems with real business goals.

让我们更进一步，通过 RACI 热图来展示为什么人类是 GenAISys 的关键组成部分。

Let’s take this further and look at a RACI heatmap to show why humans are a critical component of a GenAISys.

GenAISys RACI

GenAISys RACI

组织一个 GenAISys 项目所需的人力资源远远超出了人工智能自动化所能提供的范畴。仅靠自身力量就能提供。RACI是一种责任分配矩阵。这有助于明确每项任务的角色和职责。或者，通过明确谁是负责人、谁承担责任、谁被咨询、谁被告知，即可做出决策。RACI 模型非常适合管理构建 GenAISys 的复杂性。它为系统生命周期中不断增长的人员角色列表添加了结构，并为协调他们的参与提供了一个务实的框架。

Organizing a GenAISys project requires human resources that go far beyond what AI automation alone can provide. RACI is a responsibility assignment matrix that helps define roles and responsibilities for each task or decision by identifying who is Responsible, Accountable, Consulted, and Informed. RACI is ideal for managing the complexity of building a GenAISys. It adds structure to the growing list of human roles required during the system’s life cycle and provides a pragmatic framework for coordinating their involvement.

如同任何复杂的项目一样，参与 GenAISys 项目的团队需要跨学科协作，而 RACI 模型有助于明确每个人的职责。RACI 中的每个字母都代表一种特定的角色：

As in any complex project, teams working on a GenAISys need to collaborate across disciplines, and RACI helps define who does what. Each letter in RACI stands for a specific type of role:

• R（负责人）：积极参与任务的人员。他们负责确保工作顺利完成。例如，机器学习工程师可能负责使用机器学习算法处理数据集。
• R (Responsible): The person(s) who works actively on the task. They are responsible for the proper completion of the work. For example, an MLE may be responsible for processing datasets with ML algorithms.
• A（责任人）：对任务的成败负有责任的人员。他们监督其他人负责执行的任务。例如，产品负责人（PO）必须确保制造工程师（MLE）的任务按时完成并符合规范。否则，产品负责人将承担责任。
• A (Accountable): The person(s) answerable for the success or failure of a task. They oversee the task that somebody else is responsible for carrying out. For example, the product owner (PO) will have to make sure that the MLE’s task is done on time and in compliance with the specifications. If not, the PO will be accountable for the failure.
• C（咨询人员）：为团队其他成员提供意见、建议和反馈的人员。他们不负责执行具体工作。例如，零售业领域的专家可以帮助机器学习工程师理解机器学习算法的目标。
• C (Consulted): The person(s) providing input, advice, and feedback to help the others in a team. They are not responsible for executing the work. For example, a subject-matter expert in retail may help the MLE understand the goal of an ML algorithm.
• 我（知情者）：随时了解任务进展或结果的人员。他们不参与任务但只想了解情况或需要做出决策。例如，数据隐私官( DPO ) 希望了解系统的安全功能。
• I (Informed): The person(s) kept in the loop about the progress or outcome of a task. They don’t participate in the task but want to be simply informed or need to make decisions. For example, a data privacy officer (DPO) would like to be informed about a system’s security functionality.

种族热力图通常包含项目中每个人员角色的图例。让我们创建一个包含以下角色的热力图：

A RACI heatmap typically contains legends for each human role in a project. Let’s build a heatmap with the following roles:

• MLE开发并整合人工智能模型
• The MLE develops and integrates AI models
• DE设计数据管理管道
• The DE designs data management pipelines
• 后端构建API 交互
• The BE builds API interactions
• 前端工程师（FE）负责开发最终用户功能。
• The frontend engineer (FE) develops end user features
• UI /UX设计师负责设计用户界面。
• The UI/UX designer designs user interfaces
• CE /DevOps工程师负责管理云基础设施
• The CE/DevOps engineer manages cloud infrastructure
• 提示工程师（PE）设计最优提示
• The prompt engineer (PE) designs optimal prompts
• 安全执行机构 ( SE )负责处理安全数据和访问。
• The SE handles secure data and access
• 数据保护官 ( DPO )负责管理数据治理和法规遵从
• The DPO manages data governance and regulation compliance
• 法律/合规官（LC）负责审查项目的法律范围。
• The legal/compliance officer (LC) reviews the legal scope of a project
• QAE对GenAISys进行测试。
• The QAE tests the GenAISys
• 采购订单定义产品的范围和规模
• The PO defines the scope and scale of a product
• 项目经理负责协调资源和时间表。
• The PM coordinates resources and timelines
• 技术文档撰写员（TW ）负责编写文档。
• The technical writer (TW) produces documentation
• 供应商经理（VM）与外部供应商和服务提供商进行沟通
• The vendor manager (VM) communicates with external vendors and service providers

并非每个 GenAISys 项目都会包含所有这些角色，但这取决于项目的范围和规模。这个项目中，很多环节都至关重要。现在，让我们来列举一下。在典型的生成式人工智能项目中，上述角色的主要职责如下：

Not every GenAISys project will include all of these roles, but depending on the scope and scale of the project, many of them will be critical. Now, let’s list the key responsibilities of the roles defined above in a typical generative AI project:

• 模型：人工智能模型开发
• Model: AI model development
• 控制器：API 和多模态组件的编排
• Controller: Orchestration of APIs and multimodal components
• 管道：数据处理和集成工作流程
• Pipelines: Data processing and integration workflows
• UI/UX：用户界面和用户体验设计
• UI/UX: User interface and experience design
• 安全：数据保护和访问控制
• Security: Data protection and access control
• DevOps：基础设施、扩展和监控
• DevOps: Infrastructure, scaling, and monitoring
• 提示：设计和优化模型交互
• Prompts: Designing and optimizing model interactions
• 质量保证：测试和质量保证
• QA: Testing and quality assurance

我们已经定义了角色和任务。现在，我们可以展示如何将它们映射到实际场景中。图 1.6展示了一个 GenAISys 的 RACI 热力图示例。

We’ve defined the roles and the tasks. Now, we can show how they can be mapped to a real-world scenario. Figure 1.6 illustrates an example RACI heatmap for a GenAISys.

图 1.6：RACI 热图示例

Figure 1.6: Example of a RACI heatmap

例如，在此热力图，MLE 具有以下职责：

For example, in this heatmap, the MLE has the following responsibilities:

• （R）负责和（A）对模型负责，该模型可能是 GPT-4o。
• (R)esponsible and (A)ccountable for the model, which could be GPT-4o.
• （R）负责且（A）对模型提示负有责任
• (R)esponsible and (A)ccountable for the prompts for the model
• （C）作为专家为控制器、管道和测试（质量保证）提供咨询
• (C)onsulted as an expert for the controller, the pipeline, and testing (QA)
• 我了解了用户界面/用户体验、安全性和DevOps方面的内容。
• (I)nformed about the UI/UX, security, and DevOps

我们可以用一条简单的规则来概括 GenAISys 的运作方式：

We can sum it up with one simple rule for a GenAISys:

没有人，就没有系统！

No humans -> no system!

我们可以看到，在 GenAISys 的整个生命周期中，从设计到维护和支持，包括根据用户反馈不断进行迭代更新，我们都是必不可少的。人类一直存在，并将长期存在！接下来，让我们探讨 GenAISys 可以带来的商业机遇。

We can see that we are necessary during the whole life cycle of a GenAISys, from design to maintenance and support, including continual evolutions to keep up with user feedback. Humans have been and will be here for a long time! Next, let’s explore the business opportunities that a GenAISys can unlock.

商业机会和范围

Business opportunities and scope

我们往往无法获得 OpenAI、Meta、xAI 或 Microsoft Azure 等公司价值数十亿美元的庞大资源来构建类似 ChatGPT 的平台。上一节已经表明了这一点。在类似 ChatGPT 那样看似简单流畅的界面之下，隐藏着复杂的底层架构，包括昂贵的基础设施、稀缺人才以及持续的改进和演进，这些都需要耗费大量资源，只有大型企业才能负担得起。因此，更明智的做法是从一开始就确定项目类别，并利用现有模块和库的强大功能来构建我们的 GenAISys。无论应用场景如何，例如市场营销、财务、生产或支持，我们都需要找到合适的范围和规模，才能实现一个切实可行的 GenAISys。

More often than not, we will not have access to the incredible billion-dollar resources of OpenAI, Meta, xAI, or Microsoft Azure to build ChatGPT-like platforms. The previous section showed that beneath a ChatGPT-like, seemingly simple, seamless interface, there is a complex layer of expensive infrastructure, rare talent, and continuous improvement and evolution that absorb resources only large corporations can afford. Therefore, a smarter path from the start is to determine which project category we are in and leverage the power of existing modules and libraries to build our GenAISys. Whatever the use case, such as marketing, finance, production, or support, we need to find the right scope and scale to implement a realistic GenAISys.

如前所述，任何 GenAISys 的第一步都是定义项目的目标（机会），包括其范围和规模。在此步骤中，您将评估风险，例如成本、保密性和资源可用性（风险管理）。

The first step of any GenAISys is to define the project’s goal (opportunity), including its scope and scale, as we mentioned. During this step, you will assess the risks, such as costs, confidentiality, and resource availability (risk management).

我们可以根据我们的资源、目标、用例的复杂性和预算，将 GenAISys 项目分为三种主要业务实施类型。如图 1.7所示：

We can classify GenAISys projects into three main business implementation types depending on our resources, our objectives, the complexity of our use case, and our budget. These are illustrated in Figure 1.7:

• 混合方法：利用现有的人工智能平台
• Hybrid approach: Leveraging existing AI platforms
• 小范围、小规模：一个专注的 GenAISys
• Small scope and scale: A focused GenAISys
• 全规模生成式多智能体人工智能系统：一个完整​​的 ChatGPT 级生成式人工智能平台
• Full-scale generative multi-agent AI system: A complete ChatGPT-level generative AI platform

图 1.7：GenAISys 的三大主要业务应用

Figure 1.7: The three main GenAISys business implementations

让我们从混合方法开始，这是一种在不过度建设的情况下实现业务成果的实用方法。

Let’s begin with a hybrid approach, a practical way to deliver business results without overbuilding.

混合方法

Hybrid approach

混合动力框架使您能够通过将现成的 SaaS 平台与仅在必要时开发的定制组件（例如网络搜索和数据清洗）相结合，最大限度地降低开发成本和时间。这样，您无需从零开始开发所有内容，即可利用生成式 AI 的强大功能。接下来，我们将介绍其关键特性和一些用例示例。

A hybrid framework enables you to minimize development costs and time by combining ready-to-use SaaS platforms with custom-built components developed only when necessary, such as web search and data cleansing. This way, you can leverage the power of generative AI without developing everything from scratch. Let’s go through the key characteristics and a few example use cases.

主要特征

Key characteristics

• 依靠成熟的网络服务，例如 OpenAI 的 GPT API、AWS、Google AI 或 Microsoft Azure。这些平台提供核心的生成功能。
• Relying on proven web services such as OpenAI’s GPT API, AWS, Google AI, or Microsoft Azure. These platforms provide the core generative functionality.
• 通过集成特定领域的矢量存储库和您组织的专有数据集来定制您的项目。
• Customizing your project by integrating domain-specific vector stores and your organization’s proprietary datasets.
• 专注于特定功能的开发，例如客户支持自动化或营销活动生成。
• Focusing development on targeted functionality, such as customer support automation or marketing campaign generation.

使用案例示例

Use case examples

• 实施特定领域的向量存储库，用于处理法律、医疗或产品相关的客户查询
• Implementing a domain-specific vector store to handle legal, medical, or product-related customer queries
• 在具有实时功能的社交媒体平台上构建客户支持
• Building customer support on a social media platform with real-time capabilities

这一类别能够以更少的资源（包括成本和开发工作量）实现更多功能。混合系统可以是独立的 GenAISys，也可以是大型生成式人工智能平台中的一个子系统，无需进行全面开发。接下来，我们将探讨小规模、小范围的 GenAISys 如何帮助我们走得更远。

This category offers the ability to do more with less—in terms of both cost and development effort. A hybrid system can be a standalone GenAISys or a subsystem within a larger generative AI platform where full-scale development isn’t necessary. Let’s now look at how a small-scope, small-scale GenAISys can take us even further.

小范围和规模

Small scope and scale

小型 GenAI 系统可能包含一个智能的、由 GenAI 驱动的 AI 控制器，该控制器连接到一个向量商店。此设置允许该系统无需完整的基础设施即可检索数据、触发指令并调用其他功能，例如网络搜索或机器学习。

A small-scale GenAISys might include an intelligent, GenAI-driven AI controller connected to a vector store. This setup allows the system to retrieve data, trigger instructions, and call additional functionality such as web search or ML—without needing full-scale infrastructure.

主要特征

Key characteristics

• 显然已确定的盈利系统旨在以最优的开发时间和成本实现合理的目标。
• A clearly defined profitable system designed to achieve reasonable objectives with optimal development time and cost
• AI 控制器会协调各种指令场景，这些场景会依次触发 RAG（红绿灯）、网络搜索、图像分析以及其他符合您需求的自定义任务。
• The AI controller orchestrates instruction scenarios that, in turn, trigger RAG, web search, image analysis, and additional custom tasks that fit your needs
• 重点在于高优先级、高效益的功能。
• The focus is on high-priority, productive features

使用案例示例

Use case examples

• 用于 GenAISys 的通过分块和嵌入式内容，对任何类型的文档进行文档检索和摘要，并提供细致入微的分析。
• A GenAISys for document retrieval and summarization for any type of document with nuanced analysis through chunked and embedded content
• 通过实时网络搜索增强 GPT 或 Llama 等模型，可以绕过其数据截止日期——这对于天气预报或新闻监控等应用来说非常理想。不需要持续微调
• Augmenting a model such as GPT or Llama with real-time web search to bypass its data cutoff date—ideal for applications such as weather forecasting or news monitoring that don’t need continual fine-tuning

这一类别让我们在混合方法的基础上更进一步，同时仍然保持现实性和可管理性，适用于中小型企业，甚至大型组织内的各个部门。

This category takes us a step beyond the hybrid approach, while still staying realistic and manageable for small to mid-sized businesses or even individual departments within large organizations.

全尺寸 GenAISys

Full-scale GenAISys

如果你是在专家团队中工作对于拥有充足预算和先进基础设施的组织而言，此类别正适合您。您的团队可以构建一个功能齐全的 GenAISys 系统，其功能已接近 ChatGPT 级别的平台。

If you’re working in a team of experts within an organization that has a large budget and advanced infrastructure, this category is for you. Your team can build a full-scale GenAISys that begins to approach the capabilities of ChatGPT-grade platforms.

主要特征

Key characteristics

• 全面展开AI控制器，用于管理和协调复杂的自动化工作流程，包括红绿灯、指令场景、多模态功能和实时数据。
• A full-blown AI controller that manages and orchestrates complex automated workflows, including RAG, instruction scenarios, multimodal functionality, and real-time data
• 需要大量的计算资源和高技能的开发团队
• Requires significant computing resources and highly skilled development teams

使用案例示例

Use case examples

• GenAISys是人工智能已应用于医疗保健领域，以辅助患者诊断和疾病预防。例如，巴黎居里研究所就拥有一支非常先进的人工智能研究团队：https://institut-curie.org/。
• GenAISys is already present in healthcare to assist with patient diagnosis and disease prevention. The Institut Curie in Paris, for example, has a very advanced AI research team: https://institut-curie.org/.
• 许多大型组织已开始实施 GenAISys，用于欺诈检测、天气预报和法律专业知识。
• Many large organizations have begun implementing GenAISys for fraud detection, weather predictions, and legal expertise.

您可以加入这些拥有资源的大型组织之一，以构建可持续的 GenAISys，无论是在云平台、本地服务器还是两者兼而有之。

You can join one of these large organizations that have the resources to build a sustainable GenAISys, whether it be on a cloud platform, local servers, or both.

根据组织的具体目标、预算和技术能力，GenAISys 可分为混合型、小型和全规模三种类型，为构建此类系统提供了不同的路径。本书将探讨构成 GenAISys 的关键组件。读完本书后，您将能够为任何一种类型的系统做出贡献，并为您的项目提供切实可行且技术上合理的建议。

The three categories—hybrid, small scale, and full scale—offer distinct paths for building a GenAISys, depending on your organization’s goals, budget, and technical capabilities. In this book, we’ll explore the critical components that make up a GenAISys. By the end, you’ll be equipped to contribute to any of these categories and offer realistic, technically grounded recommendations for the projects you work on.

现在让我们揭开面纱，开始在代码中构建上下文感知和记忆保持能力。

Let’s now lift the hood and begin building contextual awareness and memory retention in code.

情境意识和记忆保持

Contextual awareness and memory retention

在本节中，我们将开始实现情境感知和记忆保持的模拟。本文使用 Python 来阐述“构建 GenAISys 的内存”一节中介绍的概念。目标是展示管理上下文和内存的实用方法——随着生成式 AI 平台的不断发展，这两个特性正变得越来越重要。

In this section, we’ll begin implementing simulations of contextual awareness and memory retention in Python to illustrate the concepts introduced in the Building the memory of a GenAISys section. The goal is to demonstrate practical ways to manage context and memory—two features that are becoming increasingly critical as generative AI platforms evolve.

打开Contextual_Awareness_and_Memory_Retention.ipynb位于chapter01GitHub 仓库文件夹（https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main）中的文件。你会看到该笔记本分为五个主要部分：

Open the Contextual_Awareness_and_Memory_Retention.ipynb file located in the chapter01 folder of the GitHub repository (https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main). You’ll see that the notebook is divided into five main sections:

• 搭建环境，构建可重用函数，并将它们存储在commons代码仓库目录中，以便我们在本书中需要时可以重用它们。
• Setting up the environment, building reusable functions, and storing them in the commons directory of the repository, so we can reuse them when necessary throughout the book
• 具有语义记忆和情景记忆的无状态、无记忆会话
• Stateless and memoryless session with semantic and episodic memory
• 在会话期间进行情境意识的短期记忆训练
• Short-term memory session for context awareness during a session
• 跨多个会话的长期记忆，用于在不同会话中保持上下文记忆
• Long-term memory across multiple sessions for context retention across different sessions
• 对多个跨主题会话的长期记忆，扩展了先前独立会话的长期记忆。
• Long-term memory of multiple cross-topic sessions, expanding long-term memory over formerly separate sessions

目标是通过明确的流程来阐释每种类型的记忆。目前这些示例都特意采用手动方式，但下一章中我们将开始构建的AI控制器将实现自动化并管理这些流程。

The goal is to illustrate each type of memory in an explicit process. These examples are intentionally kept manual for now, but they will be automated and managed by the AI controller we will begin to build in the next chapter.

第一步是安装环境。

The first step is to install the environment.

建立环境

Setting up the environment

我们将我们需要commons为 GenAISys 项目创建一个目录。该目录将包含本书 GitHub 代码库中所有笔记本所需的主要模块和库。这样做的目的是为了专注于系统维护和支持的设计。因此，通过将主要模块和库集中在一个目录中，我们可以专注于需要关注的资源，而无需在每个笔记本中重复设置步骤。此外，本节还将作为本书 GitHub 代码库中所有笔记本的参考点。我们只会描述每个资源的下载过程一次，然后在本书中重复使用它们来构建我们的教学用 GenAISys。

We will need a commons directory for our GenAISys project. This directory will contain the main modules and libraries needed across all notebooks in this book’s GitHub repository. The motivation is to focus on designing the system for maintenance and support. As such, by grouping the main modules and libraries in one directory, we can zero in on a resource that requires our attention instead of repeating the setup steps in every notebook. Furthermore, this section will serve as a reference point for all the notebooks in this book’s GitHub repository. We’ll only describe the downloading of each resource once and then reuse them throughout the book to build our educational GenAISys.

因此，我们可以从该目录下载 notebook 资源commons并安装所需的依赖项。

Thus, we can download the notebook resources from the commons directory and install the requirements.

第一个下一步是下载grequests.py一个实用脚本，我们将在本书中一直使用它。它包含一个函数，可以直接从 GitHub 下载我们需要的文件：

The first step is to download grequests.py, a utility script we will use throughout the book. It contains a function to download the files we need directly from GitHub:

!curl -L https://raw.githubusercontent.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/master/commons/grequests.py --output grequests.py

此脚本的目标是通过调用download以下函数从存储库的任意目录下载文件grequests：

The goal of this script is to download a file from any directory of the repository by calling the download function from grequests:

import sys
import subprocess 
from grequests import download
download([directory],[file])

此函数使用curl命令从指定的目录和文件名下载文件。它还包含基本的错误处理机制，以应对命令执行失败的情况。

This function uses a curl command to download files from a specified directory and filename. It also includes basic error handling in case of command execution failures.

代码首先导入subprocess用于处理路径和命令的模块。该download函数包含两个参数：

The code begins by importing subprocess to handle paths and commands. The download function contains two parameters:

def download(directory, filename):

• directory文件所在的 GitHub 仓库子目录
• directory: The subdirectory of the GitHub repository where the file is stored
• filename要下载的文件名
• filename: The name of the file to download

然后定义 GitHub 仓库的基本 URL，指向我们需要的原始文件：

The base URL for the GitHub repository is then defined, pointing to the raw files we will need:

base_url = 'https://raw.githubusercontent.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/main/'

directory现在我们需要使用`and`参数定义文件的完整 URL filename：

We now need to define the file’s full URL with the directory and filename parameters:

file_url = f"{base_url}{directory}/{filename}"

该函数现在定义了该curl命令：

The function now defines the curl command:

curl_command = f'curl -o {filename} {file_url}'

最后，download命令被执行：

Finally, the download command is executed:

subprocess.run(curl_command, check=True, shell=True)

• check=Truecurl如果命令执行失败，则触发异常。
• check=True activates an exception if the curl command fails
• shell=True通过 shell 运行命令。
• shell=True runs the command through the shell

街区try-except​用于处理错误：

The try-except block is used to handle errors:

try:
    # Prepare the curl command with the Authorization header
    curl_command = f'curl -o {filename} {file_url}'
    # Execute the curl command
    subprocess.run(curl_command, check=True, shell=True)
    print(f"Downloaded '{filename}' successfully.")
except subprocess.CalledProcessError:
    print(f"Failed to download '{filename}'. Check the URL and your internet connection")

我们现在有了一个独立的下载脚本，本书将全程使用它。接下来，让我们下载本程序所需的资源。

We now have a standalone download script that we’ll use throughout the book. Let’s go ahead and download the resources we need for this program.

下载 OpenAI 资源

Downloading OpenAI resources

我们需要本笔记本包含三个参考资料：

We need three resources for this notebook:

• requirements01.py安装我们想要的精确 OpenAI 版本
• requirements01.py to install the precise OpenAI version we want
• openai_setup.py初始化 OpenAI API 密钥
• openai_setup.py to initialize the OpenAI API key
• openai_api_py包含一个可重用的调用 GPT-4o 模型的函数，因此您无需在多个单元格或笔记本中重复编写相同的代码。
• openai_api_py contains a reusable function for calling the GPT-4o model, so you don’t need to rewrite the same code across multiple cells or notebooks

我们可以使用以下函数下载这些文件download()：

We can download these files with the download() function:

from grequests import download
download("commons","requirements01.py")
download("commons","openai_setup.py")
download("commons","openai_api.py")

第一个资源是requirements01.py。

The first resource is requirements01.py.

安装 OpenAI

Installing OpenAI

requirements01.py确保安装特定版本的 OpenAI 库，以避免冲突。与其他已安装的库一起使用。因此，代码会卸载现有版本，强制安装请求的指定版本，并验证结果。该函数执行安装时会进行错误处理：

requirements01.py makes sure that a specific version of the OpenAI library is installed to avoid conflicts with other installed libraries. The code thus uninstalls existing versions, force-installs the specified version requested, and verifies the result. The function executes the installation with error handling:

def run_command(command):
    try:
        subprocess.check_call(command)
    except subprocess.CalledProcessError as e:
        print(f"Command failed: {' '.join(command)}\nError: {e}")
        sys.exit(1)

该功能的第一步是卸载当前已安装的 OpenAI 库：

The first step for the function is to uninstall the current OpenAI library, if there is one:

print("Installing 'openai' version 1.57.1...")
run_command([sys.executable, "-m", "pip", "install", "--force-reinstall", "openai==1.57.1"])

该函数随后会安装特定版本的 OpenAI：

The function then installs a specific version of OpenAI:

run_command(
    [
        sys.executable, "-m", "pip", "install", 
        "--force-reinstall", "openai==1.57.1"
    ]
)

最后，该函数会验证 OpenAI 是否已正确安装：

Finally, the function verifies that OpenAI is properly installed:

try:
    import openai
    print(f"'openai' version {openai.__version__} is installed.")
except ImportError:
    print("Failed to import the 'openai' library after installation.")
    sys.exit(1)

输出函数末尾应如下所示：

The output at the end of the function should be as follows:

'openai' version 1.57.1 is installed.

现在我们可以初始化 OpenAI API 密钥了。

We can now initialize the OpenAI API key.

OpenAI API 密钥初始化

OpenAI API key initialization

有初始化 OpenAI 的两种方法笔记本中的 API 密钥：

There are two methods to initialize the OpenAI API key in the notebook:

1. 使用 Google Colab 密钥：点击 Google Colab 左侧窗格中的钥匙图标（如图 1.8所示），然后点击“添加新密钥”，并添加您的密钥，密钥名称应与您在笔记本中使用的密钥变量名称相同：
1. Using Google Colab secrets: Click on the key icon in the left pane in Google Colab, as shown in Figure 1.8, then click on Add new secret and add your key with the name of the key variable you will use in the notebook:

图 1.8：添加新的 Google 密钥

Figure 1.8: Add a new Google secret key

openai_setup然后，我们可以在我们的函数中调用 Google 的函数来初始化密钥openai_setup.py：

Then, we can use Google’s function to initialize the key by calling it in our openai_setup function in openai_setup.py:

# Import libraries
import openai
import os
from google.colab import userdata
# Function to initialize the OpenAI API key
def initialize_openai_api():
# Function to initialize the OpenAI API key
def initialize_openai_api():
    # Access the secret by its name
    API_KEY = userdata.get('API_KEY')
   
    if not API_KEY:
        raise ValueError("API_KEY is not set in userdata!")
   
    # Set the API key in the environment and OpenAI
    os.environ['OPENAI_API_KEY'] = API_KEY
    openai.api_key = os.getenv("OPENAI_API_KEY")
    print("OpenAI API key initialized successfully.")

google_secrets如果设置为True：则此方法被激活

This method is activated if google_secrets is set to True:

google_secrets=True
if google_secrets==True:
    import openai_setup
    openai_setup.initialize_openai_api()

• 自定义安全方式：您也可以选择自定义方式或输入密钥。您可以通过以下方式启用此功能：将代码设置google_secrets为 `true` False，取消注释以下代码，然后直接输入您的 API 密钥，或使用您选择的任何方法：

  if google_secrets==False: # Uncomment the code and choose any method you wish to initialize the API_KEY
      import os
      #API_KEY=[YOUR API_KEY]
      #os.environ['OPENAI_API_KEY'] = API_KEY
      #openai.api_key = os.getenv("OPENAI_API_KEY")
      #print("OpenAI API key initialized successfully.")
  

• Custom secure method: You can also choose a custom method or enter the key in the code by setting google_secrets to False, uncommenting the following code, and entering your API key directly, or any method of your choice:

  if google_secrets==False: # Uncomment the code and choose any method you wish to initialize the API_KEY
      import os
      #API_KEY=[YOUR API_KEY]
      #os.environ['OPENAI_API_KEY'] = API_KEY
      #openai.api_key = os.getenv("OPENAI_API_KEY")
      #print("OpenAI API key initialized successfully.")
  

这两种情况下，代码都会创建一个环境变量：

In both cases, the code will create an environment variable:

os.environ['OPENAI_API_KEY'] = API_KEY
openai.api_key = os.getenv("OPENAI_API_KEY")

OpenAI API 密钥已初始化。现在我们将导入一个自定义的 OpenAI API 调用。

The OpenAI API key is initialized. We will now import a custom OpenAI API call.

OpenAI API 调用

OpenAI API call

目标接下来是在openai_api.py其中创建一个 OpenAI API 调用函数。我们可以用两行代码导入：

The goal next is to create an OpenAI API call function in openai_api.py that we can import in two lines:

#Import the function from the custom OpenAI API file
import openai_api
from openai_api import make_openai_api_call

因此，该函数被设计成在调用时接收四个变量并无缝地显示它们：

The function is thus built to receive four variables when making the call and display them seamlessly:

# API function call
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role)
print(response)

该函数的参数如下：

The parameters in this function are the following:

• input包含输入（用户或系统），例如：Where is Hawaii?
• input: Contains the input (user or system), for example, Where is Hawaii?
• mrole定义系统的角色，例如，You are a geology expert.或者简单地System.
• mrole: Defines the system’s role, for example, You are a geology expert. or simply System.
• mcontent例如，我们期望系统是什么样的？You are a geology expert.
• mcontent: Is what we expect the system to be, for example, You are a geology expert.
• user_role定义用户角色，例如：user
• user_role: Defines the role of the user, for example, user

第一个函数中的部分代码定义了我们将在此过程中使用的模型。notebook 会创建一个消息对象，用于 API 调用，并传入我们发送的参数：

The first part of the code in the function defines the model we will be using in this notebook and creates a message object for the API call with the parameters we sent:

def make_openai_api_call(input, mrole,mcontent,user_role):
    # Define parameters
    gmodel = "gpt-4o"
    # Create the messages object
    messages_obj = [
        {
            "role": mrole,
            "content": mcontent
        },
        {
            "role": user_role,
            "content": input
        }
    ]

然后，我们在这个笔记本的字典中定义 API 调用参数：

We then define the API call parameters in a dictionary for this notebook:

# Define all parameters in a dictionary named params:
    params = {
        "temperature": 0,
        "max_tokens": 256,
        "top_p": 1,
        "frequency_penalty": 0,
        "presence_penalty": 0
    }

字典参数如下：

The dictionary parameters are the following:

• temperature控制响应的随机性。0数值越低，响应越具有确定性。数值越高 （例如，0.7），响应越具有创造性。
• temperature: Controls the randomness of a response. 0 will produce deterministic responses. Higher values (e.g., 0.7) will produce more creative responses.
• max_tokens限制响应中令牌的最大数量。
• max_tokens: Limits the maximum number of tokens of a response.
• top_p：产生核心采样。它通过以累积概率为 1 从前几个标记中进行采样来控制响应的多样性。
• top_p: Produces nucleus sampling. It controls the diversity of a response by sampling from the top tokens with a cumulative probability of 1.
• frequency_penalty：减少标记重复以避免冗余。0将不施加任何惩罚，以及2施加强惩罚。在这种情况下，0由于 OpenAI 模型的高性能，已足够。
• frequency_penalty: Reduces the repetition of tokens to avoid redundancies. 0 will apply no penalty, and 2 a strong penalty. In this case, 0 is sufficient because of the high performance of the OpenAI model.
• presence_penalty：通过惩罚现有内容来鼓励新内容的产生，从而避免冗余。它适用于与频率惩罚相同的值。在这种情况下，由于 OpenAI 模型的高性能，因此不需要此控制。
• presence_penalty: Encourages new content by penalizing existing content to avoid redundancies. It applies to the same values as for the frequency penalty. In this case, due to the high performance of the OpenAI model, it doesn’t require this control.

然后我们初始化 OpenAI 客户端，为 API 调用创建实例：

We then initialize the OpenAI client to create an instance for the API calls:

    client = OpenAI()

最后，我们制作通过发送模型、消息对象和解压后的参数来调用 API：

Finally, we make the API call by sending the model, the message object, and the unpacked parameters:

    # Make the API call
    response = client.chat.completions.create(
        model=gmodel,
        messages=messages_obj,
        **params  # Unpack the parameters dictionary
    )

该函数最后返回我们需要的 API 响应内容：

The function ends by returning the content of the API’s response that we need:

    #Return the response
    return response.choices[0].message.content

此功能将帮助我们专注于 GenAISys 架构，而无需在笔记本中添加重复的库和函数。

This function will help us focus on the GenAISys architecture without having to overload the notebook with repetitive libraries and functions.

笔记本里有以下内容：

In the notebook, we have the following:

• 该程序向函数提供输入、角色和消息内容。
• The program provides the input, roles, and message content to the function
• messages_obj包含对话历史记录
• messages_obj contains the conversation history
• API 行为的参数在params字典中定义。
• The parameters for the API’s behavior are defined in the params dictionary
• 使用 OpenAI 客户端向 OpenAI 模型发出 API 调用。
• An API call is made to the OpenAI model using the OpenAI client
• 该函数仅返回人工智能的响应内容。
• The function returns only the AI’s response content

现在让我们构建并运行一个无状态、无内存的会话。

Let’s now build and run a stateless and memoryless session.

1. 无状态和无记忆会话

1. Stateless and memoryless session

如果我们只想与他人进行一次临时的单次交换，那么无状态、无记忆的会话就很有用。请求之间不存储任何信息。本节中的示例既是无状态的，也是无内存的：

A stateless and memoryless session is useful if we only want a single and temporary exchange with no stored information between requests. The examples in this section are both stateless and memoryless:

• 无国籍人士每个请求都将独立处理。
• Stateless indicates that each request will be processed independently
• 无记忆意味着没有机制可以记住过去的交易记录。
• Memoryless means that there is no mechanism to remember past exchanges

让我们从一个语义查询开始。

Let’s begin with a semantic query.

语义查询

Semantic query

此请求期待得到纯粹语义上、事实性的回应：

This request expects a purely semantic, factual response:

uinput = "Hawai is on a geological volcano system. Explain:"
mrole = "system"
mcontent = "You are an expert in geology."
user_role = "user"

现在，我们调用 OpenAI API 函数：

Now, we call the OpenAI API function:

# Function call
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role)
print(response)

如您所见，该回复纯粹是语义上的：

As you can see, the response is purely semantic:

Hawaii is located on a volcanic hotspot in the central Pacific Ocean, which is responsible for the formation of the Hawaiian Islands. This hotspot is a region where magma from deep within the Earth's mantle rises to the surface, creating volcanic activity…

下一个查询是按剧情进行的。

The next query is episodic.

带有语义意味的情景式查询

Episodic query with a semantic undertone

本例中的查询是情景式的，并且基于个人经验。然而，它具有语义意义。因为对夏威夷的描述而带有弦外之音。以下是其传递的信息，颇具诗意：

The query in this example is episodic and draws on personal experience. However, there is a semantic undertone because of the description of Hawaii. Here’s the message, which is rather poetic:

# API message
uinput = "I vividly remember my family's move to Hawaii in the 1970s, how they embraced the warmth of its gentle breezes, the joy of finding a steady job, and the serene beauty that surrounded them. Sum this up in one nice sentence from a personal perspective:"
mrole = "system"
mcontent = "You are an expert in geology."
user_role = "user"

如有必要，我们可以在函数调用之前插入外部信息。例如，我们可以添加一些来自其他来源的信息，例如当天收到的来自家人的短信：

We could insert external information before the function call if necessary. For example, we could add some information from another source, such as a text message received that day from a family member:

text_message='I agree, we had a wonderful time there.'
uninput=text_message+uinput
text_message="Hi, I agree, we had a wonderful time there."

现在，我们调用该函数：

Now, we call the function:

# Call the function
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role)
print(response)

我们发现，该回答大多是情景式的，只包含一些语义信息：

We see that the response is mostly episodic with some semantic information:

Moving to Hawaii in the 1970s was a transformative experience for my family, as they found joy in the island's gentle breezes, the security of steady employment, and the serene beauty that enveloped their new home.

无状态和无记忆验证

Stateless and memoryless verification

我们添加了之前没有记忆保留功能，导致对话框处于无状态。我们来检查一下：

We added no memory retention functionality earlier, making the dialogue stateless. Let’s check:

# API message
uinput = "What question did I just ask you?"
mrole = "system"
mcontent = "You already have this information"
user_role = "user"

当我们调用该函数后，我们的对话将被遗忘：

When we call the function, our dialogue will be forgotten:

# API function call
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role
)
print(response)

输出结果证实该会话是无记忆的：

The output confirms that the session is memoryless:

I'm sorry, but I can't recall previous interactions or questions. Could you please repeat your question?

由于 OpenAI API 不会在请求之间保留内存，因此 API 调用是无状态的。如果我们直接使用 ChatGPT，则会话中的对话内容会被记忆。这会对实现产生关键影响。这意味着我们必须构建自己的内存机制，才能使 GenAISys 具备状态行为。让我们从第一层开始：短期记忆。

The API call is stateless because the OpenAI API does not retain memory between requests. If we were using ChatGPT directly, the exchanges would be memorized within that session. This has a critical impact on implementation. It means we have to build our own memory mechanisms to give GenAISys stateful behavior. Let’s start with the first layer: short-term memory.

2. 短期记忆测试

2. Short-term memory session

这本节目标是通过两步过程来模拟短期记忆过程：

The goal of this section is to emulate a short-term memory session using a two-step process:

1. 首先，我们启动一个会话，该会话从用户输入到响应：
1. First, we initiate a session that goes from user input to a response:

用户输入 => 生成模型 API 调用 => 响应

User input => Generative model API call => Response

为了实现第一步，我们将会话运行到收到响应为止：

To achieve this first step, we run the session up to the response:

uinput = "Hawai is on a geological volcano system. Explain:"
mrole = "system"
mcontent = "You are an expert in geology."
user_role = "user"
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role)
print(response)

响应的输出存储在response：

The response’s output is stored in response:

"Hawaii is part of a volcanic system known as a hotspot, which is a region of the Earth's mantle where heat rises as a thermal plume from deep within the Earth. This hotspot is responsible for the formation of the Hawaiian Islands. Here's how the process works:…"

2. 下一个步骤一是将之前的交互输入到下一个提示，以及一个后续问题：
   • 请解释一下情况：The current dialog session is:
   • 添加用户初始输入：Hawai is on a geological volcano system. Explain:
   • 将我们在上一次通话中获得的响应添加进去。
   • 添加用户的新输入：Sum up your previous response in a short sentence in a maximum of 20 words.
2. The next step is to feed the previous interaction into the next prompt, along with a follow-up question:
   • Explain the situation: The current dialog session is:
   • Add the user’s initial input: Hawai is on a geological volcano system. Explain:
   • Add the response we obtained in the previous call
   • Add the user’s new input: Sum up your previous response in a short sentence in a maximum of 20 words.

此处的目的是压缩会话日志。我们并非总是需要压缩对话，但在较长的会话中，大量的上下文窗口会迅速累积。这项技术有助于降低令牌数量，这对于成本和性能都至关重要。在本例中，我们仅管理一个响应，因此如果需要，我们可以将整个交互过程保存在内存中。尽管如此，这个例子仍然引入了一个便于扩展的实用技巧。

The goal here is to compress the session log. We won’t always need to compress dialogues, but in longer sessions, large context windows can pile up quickly. This technique helps keep the token count low, which matters for both cost and performance. In this particular case, we’re only managing one response, so we could keep the entire interaction in memory if we wanted to. Still, this example introduces a useful habit for scaling up.

提示信息组装完毕后：

Once the prompt is assembled:

• 调用 API 函数
• Call the API function
• 显示响应
• Display the response

该场景在代码中进行了说明：

The scenario is illustrated in the code:

ninput = "Sum up your previous response in a short sentence in a maximum of 20 words."
uinput = (
    "The current dialog session is: " +
    uinput +
    response +
    ninput
)
response = openai_api.make_openai_api_call(
    uinput, mrole, mcontent, user_role
)
print("New response:", "\n\n", uinput, "\n", response)

输出结果提供了一个简洁明了的对话摘要：

The output provides a nice, short summary of the dialogue:

New response: Hawaii's islands form from volcanic activity over a stationary hotspot beneath the moving Pacific Plate.

这功能虽然这里并非绝对必要，但这为我们之后在书中遇到的更长的对话做了铺垫。接下来，我们来构建一个包含多个会话的长期模拟。

This functionality wasn’t strictly necessary here, but it sets us up for the longer dialogues we’ll encounter later in the book. Next, let’s build a long-term simulation of multiple sessions.

3. 多次会话的长期记忆

3. Long-term memory of multiple sessions

在本节中，我们将通过延续之前某个对话来模拟长期记忆。不同之处在于，我们不仅仅是记住单次会议中的对话——我们是在重复利用过去会议的内容来扩展会议内容。对话。此时，“会话”一词的含义更加广泛。在传统的副驾驶场景中，一个用户在一个独立的会话中与一个模型进行交互。而在这里，我们融合了多个会话，并支持多个子会话。多个用户可以在共享环境中与模型交互，从而有效地创建了一个具有分支内存线程的全局会话。您可以将模型想象成正在进行的 Zoom 或 Teams 会议中的一位嘉宾。您可以邀请这位 AI 嘉宾参与讨论，也可以让他保持沉默——当它加入会议时，可能需要一些简要说明。

In this section, we’re simulating long-term memory by continuing a conversation from an earlier session. The difference here is that we’re not just remembering a dialogue from a single session—we’re reusing content from a past session to extend the conversation. At this point, the term “session” takes on a broader meaning. In a traditional copilot scenario, one user interacts with one model in one self-contained session. Here, we’re blending sessions and supporting multiple sub-sessions. Multiple users can interact with the model in a shared environment, effectively creating a single global session with branching memory threads. Think of the model as a guest in an ongoing Zoom or Teams meeting. You can ask the AI guest to participate or stay quiet—and when it joins, it may need a recap.

为了避免重复上次对话的开头部分，我们将重用刚刚进行的短期记忆训练的内容。假设上一次训练已经结束，但我们仍然希望从上次中断的地方继续：

To avoid repeating the first steps of the past conversation, we’re reusing the content from the short-term memory session we just ran. Let’s assume the previous session is over, but we still want to continue from where we left off:

session01=response
print(session01)

输出结果包含我们短期记忆会话的最终响应：

The output contains the final response from our short-term memory session:

Hawaii's islands form from volcanic activity over a stationary hotspot beneath the moving Pacific Plate.

这过程中本节内容将建立在上一节课的基础上，类似于你与在线副驾驶隔了一段时间后重新进行对话：

The process in this section will build on the previous session, similar to how you’d revisit a conversation with an online copilot after some time away:

保存上一个会话 => 加载上一个会话 => 将其添加到新会话的场景中

Save previous session => Load previous session => Add it to the new session’s scenario

我们先来测试一下 API 是否能够自行记住任何信息：

Let’s first test whether the API remembers anything on its own:

uinput="Is it safe to go there on vacation"
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role
)
print(response)

输出结果显示它忘记了我们之前的对话：

The output shows that it forgot the conversation we were in:

I'm sorry, but I need more information to provide a helpful response. Could you specify the location you're considering for your vacation? …

由于无状态 API 不会保留过去的对话，因此 API 会忘记之前的调用。我们需要决定提示信息中包含哪些内容。我们有以下几种选择：

The API forgot the previous call because stateless APIs don’t retain past dialogue. It’s up to us to decide what to include in the prompt. We have a few choices:

• 我们是否希望通过大量消耗代币来记住所有事情？
• Do we want to remember everything with a large consumption of tokens?
• 我们是要总结之前对话的部分内容，还是全部内容？
• Do we want to summarize parts or all of the previous conversations?

在实际的GenAISys系统中，当输入触发请求时，AI控制器会决定对任务应用哪种策略是最佳的。代码现在会将上一次会话的上下文和记忆与新的请求关联起来：

In a real GenAISys, when an input triggers a request, the AI controller decides which is the best strategy to apply to a task. The code now associates the previous session’s context and memory with a new request:

ninput = "Let's continue our dialog."
uinput=ninput + session01 + "Would it be safe to go there on vacation?"
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role
)
print("Dialog:", uinput,"\n")
print("Response:", response)

回应这表明该系统现在能够记住过去。会话包含足够的信息，可以提供可接受的输出：

The response shows that the system now remembers the past session and has enough information to provide an acceptable output:

Response: Hawaii is generally considered a safe destination for vacation, despite its volcanic activity. The Hawaiian Islands are formed by a hotspot beneath the Pacific Plate, which creates volcanoes as the plate moves over it. While volcanic activity is a natural and ongoing process in Hawaii, it is closely monitored by the United States Geological Survey (USGS) and other agencies…

现在让我们构建一个涵盖不同主题的多节课程的长期模拟。

Let’s now build a long-term simulation of multiple sessions across different topics.

4. 对多次跨主题会议的长期记忆

4. Long-term memory of multiple cross-topic sessions

这本节演示如何将两个独立的会话合并为一个。这不是这是标准 ChatGPT 类平台提供的功能之一。通常情况下，当我们发起一个新话题时，助手只会记住当前会话中发生的事情。但在企业环境中，我们可能需要更大的灵活性——尤其是在多个用户协作时。在这种情况下，可以配置 AI 控制器，允许用户组查看和合并同一组内其他用户创建的会话。

This section illustrates how to merge two separate sessions into one. This isn’t something standard ChatGPT-like platforms offer. Typically, when we start a new topic, the copilot only remembers what’s happened in the current session. But in a corporate environment, we may need more flexibility—especially when multiple users are collaborating. In such cases, the AI controller can be configured to allow groups of users to view and merge sessions generated by others in the same group.

假设我们要总结两段不同的对话——一段是关于夏威夷火山系统的，另一段是关于组织一次去亚利桑那州的地质考察。我们首先保存上一次的长期记忆会话：

Let’s say we want to sum up two separate conversations—one about Hawaii’s volcanic systems, and another about organizing a geological field trip to Arizona. We begin by saving the previous long-term memory session:

session02=uinput + response
print(session02)

然后我们可以从另一个地点（亚利桑那州）启动一个单独的多用户子会话：

Then we can start a separate multi-user sub-session from another location, Arizona:

ninput ="I would like to organize a geological visit in Arizona."
uinput=ninput+"Where should I start?"
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role
)
#print("Dialog:", uinput,"\n")

我们现在期待收到关于亚利桑那州的回复，夏威夷除外：

We now expect a response on Arizona, leaving Hawaii out:

Response: Organizing a geological visit in Arizona is a fantastic idea, as the state is rich in diverse geological features. Here's a step-by-step guide to help you plan your trip:…

这回应可以接受。现在，我们开始吧。通过结合两个会话并提示系统进行总结，模拟跨多个主题的长期记忆：

The response is acceptable. Now, let’s simulate long-term memory across multiple topics by combining both sessions and prompting the system to summarize them:

session02=response
ninput="Sum up this dialog in a short paragraph:"
uinput=ninput+ session01 + session02
response = openai_api.make_openai_api_call(
    uinput,mrole,mcontent,user_role
)
#print("Dialog:", uinput,"\n")#optional
print("Response:", response)

系统的输出表明系统的长期记忆功能有效。我们看到第一部分是关于夏威夷的：

The system’s output shows that the long-term memory of the system is effective. We see that the first part is about Hawaii:

Response: The dialog begins by explaining the formation of Hawaii's volcanic islands as the Pacific Plate moves over a stationary hotspot, leading to active volcanoes like Kilauea….

然后，回应继续涉及亚利桑那州的部分：

Then the response continues to the part about Arizona:

It then transitions to planning a geological visit to Arizona, emphasizing the state's diverse geological features. The guide recommends researching key sites such as the Grand Canyon…

我们已经介绍了GenAISys的核心存储模式——从无状态短期记忆到多用户、多主题长期记忆。现在让我们总结一下本章内容，并进入下一阶段！

We’ve now covered the core memory modes of GenAISys—from stateless and short-term memory to multi-user, multi-topic long-term memory. Let’s now summarize the chapter’s journey and move to the next level!

概括

Summary

一个可用于商业用途的 GenAISys 系统提供的功能与 ChatGPT 等平台不相上下。它整合了生成式 AI 模型、智能体特征、红绿灯算法 (RAG)、记忆保持以及一系列机器学习和非 AI 功能——所有这些都由一个 AI 控制器协调执行。与传统流程不同，该控制器不遵循固定的步骤顺序，而是根据上下文动态地协调任务。

A business-ready GenAISys offers functionality on par with ChatGPT-like platforms. It brings together generative AI models, agentic features, RAG, memory retention, and a range of ML and non-AI functions—all coordinated by an AI controller. Unlike traditional pipelines, the controller doesn’t follow a fixed sequence of steps. Instead, it orchestrates tasks dynamically, adapting to the context.

GenAISys 通常运行在 GPT-4o 等模型上，或者任何最适合您用例的模型上。但正如我们所见，仅仅拥有 API 访问权限是不够的。上下文感知和记忆保持至关重要。虽然类似 ChatGPT 的工具默认提供这些功能，但在创建自定义系统时，我们需要自行构建这些功能。

A GenAISys typically runs on a model such as GPT-4o—or whichever model best fits your use case. But as we’ve seen, just having access to an API isn’t enough. Contextual awareness and memory retention are essential. While ChatGPT-like tools offer these features by default, we have to build them ourselves when creating custom systems.

我们探索了四种记忆类型：无记忆记忆、短期记忆、长期记忆和跨主题记忆。我们还区分了语义记忆（事实）和情景记忆（个人化的、带有时间戳的信息）。情境感知高度依赖于记忆，但情境窗口是有限的。即使我们增大窗口大小，模型仍然可能忽略复杂任务中的细微差别。这时，高级 RAG 算法就派上了用场——它将内容分解成更小的块，嵌入其中，并存储在诸如 Pinecone 之类的向量存储中。这扩展了系统能够“记住”并用于推理的内容。

We explored four types of memory: memoryless, short-term, long-term, and cross-topic. We also distinguished semantic memory (facts) from episodic memory (personal, time-stamped information). Context awareness depends heavily on memory—but context windows have limits. Even if we increase the window size, models can still miss the nuance in complex tasks. That’s where advanced RAG comes in—breaking down content into smaller chunks, embedding them, and storing them in vector stores such as Pinecone. This expands what the system can “remember” and use for reasoning.

我们还发现，无论 GenAISys 技术多么先进，都离不开人类的专业知识。从设计到部署、维护和迭代，人的因素在系统的整个生命周期中都至关重要。随后，我们根据可用资源和目标，概述了三种实际应用模型：利用现有 AI 平台的混合系统、满足特定业务需求的小规模系统，以及旨在达到 ChatGPT 级别性能的全规模系统。

We also saw that no matter how advanced GenAISys becomes, it can’t function without human expertise. From design to deployment, maintenance, and iteration, people remain critical throughout the system’s life cycle. We then outlined three real-world implementation models based on available resources and goals: hybrid systems that leverage existing AI platforms, small-scale systems for targeted business needs, and full-scale systems built for ChatGPT-grade performance.

最后，我们开始动手实践——使用 GPT-4o 在 Python 中构建了一系列内存模拟模块。这些示例为接下来的工作奠定了基础：构建一个 AI 控制器，用于管理 GenAISys 系统中的内存、上下文和编排。现在，我们已经准备好构建 GenAISys AI 控制器了！

Finally, we got hands-on—building a series of memory simulation modules in Python using GPT-4o. These examples laid the groundwork for what comes next: the AI controller that will manage memory, context, and orchestration across your GenAISys. We are now ready to build a GenAISys AI controller!

问题

Questions

1. API生成的AI模型（例如GPT）是否属于AI控制器？（是或否）
1. Is an API generative AI model such as GPT an AI controller? (Yes or No)
2. 无记忆会话是否会记住上次（或几次）交互？（是/否）
3. Does a memoryless session remember the last exchange(s)? (Yes or No)
4. RAG是否用于优化上下文窗口？（是/否）
5. Is RAG used to optimize context windows? (Yes or No)
6. 人类角色在基因人工智能系统的整个生命周期中是否重要？（是或否）
7. Are human roles important for the entire life cycle of a GenAISys? (Yes or No)
8. AI控制器能否动态运行任务？（是/否）
9. Can an AI controller run tasks dynamically? (Yes or No)
10. 小型化的GenAISys系统是否只具备有限数量的关键功能？（是/否）
11. Is a small-scale GenAISys built with a limited number of key features? (Yes or No)
12. 构建一个功能齐全的类似 ChatGPT 的系统是否需要大量资源？（是/否）
13. Does a full-scale ChatGPT-like system require huge resources? (Yes or No)
14. 多次实验是否需要长期记忆？（是/否）
15. Is long-term memory necessary across multiple sessions? (Yes or No)
16. Pinecone 等向量存储是否支持知识库和 AI 控制器功能？（是/否）
17. Do vector stores such as Pinecone support knowledge and AI controller functions? (Yes or No)
18. GenAISys能否在不具备上下文感知能力的情况下运行？（是或否）
19. Can a GenAISys function without contextual awareness? (Yes or No)

参考

References

• Tomczak, JM (2024).生成式人工智能系统：基于系统的生成式人工智能视角。https ://arxiv.org/pdf/2407.11001
• Tomczak, J. M. (2024). Generative AI Systems: A Systems-based Perspective on Generative AI. https://arxiv.org/pdf/2407.11001
• Zewe, A. (2023年11月9日)。详解：生成式人工智能。麻省理工学院新闻。检索自https://news.mit.edu/2023/explained-generative-ai-1109
• Zewe, A. (2023, November 9). Explained: Generative AI. MIT News. Retrieved from https://news.mit.edu/2023/explained-generative-ai-1109
• OpenAI 模型：https://platform.openai.com/docs/models
• OpenAI models: https://platform.openai.com/docs/models
• Bommasani, R.、Hudson, DA、Adeli, E.、Altman, R.、Arora, S.、von Arx, S.、... & Liang, P. (2021)。关于基金会模型的机遇和风险。 arXiv 预印本 arXiv：2108.07258。检索自https://arxiv.org/abs/2108.07258
• Bommasani, R., Hudson, D. A., Adeli, E., Altman, R., Arora, S., von Arx, S., ... & Liang, P. (2021). On the Opportunities and Risks of Foundation Models. arXiv preprint arXiv:2108.07258. Retrieved from https://arxiv.org/abs/2108.07258

延伸阅读

Further reading

• Feuerriegel, S., Hartmann, J., Janiesch, C., & Zschech, P. (2023).生成式人工智能。商业与信息系统工程。https ://doi.org/10.1007/s12599-023-00834-7
• Feuerriegel, S., Hartmann, J., Janiesch, C., & Zschech, P. (2023). Generative AI. Business & Information Systems Engineering. https://doi.org/10.1007/s12599-023-00834-7
• Eloundou等人（2023）。GPT就是GPT：大型语言模型对劳动力市场影响潜力的早期展望。https ://arxiv.org/abs/2303.10130

  立即解锁本书的专属权益 扫描此二维码或访问packtpub.com/unlock，然后按书名搜索本书。
  注意：开始之前请准备好您的采购发票。

• Eloundou et al. (2023). GPTs are GPTs: An Early Look at the Labor Market Impact Potential of Large Language Models. https://arxiv.org/abs/2303.10130

  Unlock this book’s exclusive benefits now Scan this QR code or go to packtpub.com/unlock, then search for this book by name.
  Note: Keep your purchase invoice ready before you start.

2

2

构建生成式人工智能控制器

Building the Generative AI Controller

生成式人工智能系统（GenAISys ）的控制器需要两个关键组件：对话代理和协调器。对话代理由生成式人工智能驱动。人工智能模型负责与人类用户和系统流程进行交互。而编排器则是一系列生成式人工智能和非人工智能功能的集合，例如管理用户角色、生成内容、激活机器学习算法以及运行经典查询。我们需要这两者才能构建一个功能完善的生成式人工智能系统（GenAISys）。

A generative AI system (GenAISys)’s controller requires two key components: a conversational agent and an orchestrator. The conversational agent—powered by a generative AI model—interacts with human users and system processes. The orchestrator, on the other hand, is a set of generative AI and non-AI functions, such as managing user roles, content generation, activating machine learning algorithms, and running classical queries. We need both to build a functional GenAISys.

如果我们仔细研究这种架构，就会发现软件编排器和用户界面可以追溯到第一台计算机。任何操作系统，即使是功能最基本的，都包含用于触发磁盘空间警报、内存使用情况警报以及数百种其他功能的编排器。如今的用户界面直观易用，并具备事件驱动功能，但从宏观层面来看，GenAISys 的底层架构仍然沿袭了数十年来软件设计的基本原则。那么，传统软件控制器与 GenAISys 控制器究竟有何区别呢？

If we examine this architecture closely, we’ll see that software orchestrators and user interfaces date back to the first computers. Any operating system, with even basic functionality, has orchestrators that trigger disk space alerts, memory usage, and hundreds of other functions. Today’s user interfaces are intuitive and have event-driven functionality, but at a high level, the underlying architecture of a GenAISys still echoes decades of software design principles. So, what sets a classical software controller apart from a GenAISys controller?

我们可以用一个词来概括二者的区别：适应性。在传统的软件控制器中，任务序列或多或少是硬编码的。但在 GenAISys 中，用户界面是一个灵活的对话式 AI 代理，其背后的生成式 AI 模型经过预训练，无需额外编码即可响应各种请求。此外，编排器也不受限于静态流程；它可以根据用户（人或系统）的提示来调整触发的任务。

We can sum up the difference in one word: adaptability. In a classical software controller, a sequence of tasks is more or less hardcoded. But in a GenAISys, the user interface is a conversational AI agent that is flexible, and the generative AI model behind it is pre-trained to respond to a wide range of requests with no additional coding. Furthermore, the orchestrator isn’t locked into static flows either; it can modify the tasks it triggers based on the user (human or system) prompts.

在本章中，我们将采用实践的方式，基于上一章定义的 GenAISys 架构，构建一个自定义的 GenAISys。首先，我们将用 Python 定义 AI 控制器的结构，将其分为两部分——对话代理和编排器——并探讨二者之间的交互方式。然后，我们将使用 GPT-4o 构建对话代理。我们将实现第一章中提到的上下文感知和记忆保持功能。我们的系统将支持短期记忆和长期记忆，以及多用户和跨会话功能——这超越了标准副驾驶系统通常提供的功能。

In this chapter, we’ll take a hands-on approach to building a custom GenAISys based on the architecture of a GenAISys defined in the previous chapter. We’ll begin by defining the structure of our AI controller in Python, breaking it into two parts—the conversational agent and the orchestrator—and exploring how the two interact. Then, we’ll build the conversational agent using GPT-4o. We’ll automate the contextual awareness and memory retention features from Chapter 1. Our system will support both short-term and long-term memory, as well as multi-user and cross-session capabilities—pushing it beyond what standard copilots typically offer.

最后，我们将构建一个AI控制器的架构，用于解读用户输入并触发相应的响应场景。响应内容将是情感分析或语义（硬科学）分析，具体取决于AI控制器需要分析和管理的内容。我们定制的GenAISys将为特定领域的RAG（红绿灯）功能奠定基础，这是标准的ChatGPT级系统在处理海量数据时无法实现的，尤其是在每日更新的数据集情况下，例如产品或服务的每日销售数据。在本章结束时，您将了解如何构建GenAISys AI控制器的基础架构，我们将在本书后续章节中对其进行完善。

Finally, we will build the structure of an AI controller to interpret user input and trigger a response scenario. The response will be a sentiment analysis or a semantic (hard science) analysis, depending on the context of what the AI controller will analyze and manage. Our custom GenAISys will lay the groundwork for domain-specific RAG, something a standard ChatGPT-grade system can’t offer when you’re working with large volumes of data, especially in cases of daily dataset updates, such as the daily sales of a product or service. By the end of this chapter, you’ll know how to build the foundations of a GenAISys AI controller that we will enhance throughout the book.

总而言之，本章涵盖以下主题：

To sum up, this chapter covers the following topics:

• AI控制器的架构
• Architecture of the AI controller
• AI对话代理的架构及其工作流程
• Architecture of an AI conversational agent and its workflow
• 在代码中实现短期和长期记忆会话的存储
• Implementing the storage of short- and long-term memory sessions in code
• AI 编排器的架构和意图功能
• Architecture of an AI orchestrator and the intent functionality
• 创建包含指令场景的 GenAI 场景库
• Creating a GenAI scenario library containing instruction scenarios
• 利用向量搜索处理输入以协调指令
• Processing an input with vector search to orchestrate instructions
• 利用 GPT-4o 分析处理输入以协调指令
• Processing an input with a GPT-4o analysis to orchestrate instructions
• 使用多用途协调器根据输入选择和执行任务
• Selecting and executing tasks based on the input with the multipurpose orchestrator

我们先来定义一下人工智能控制器的架构。

Let’s begin by defining the architecture of the AI controller.

AI控制器的架构

Architecture of the AI controller

我们将继续为了实现我们在第 1 章图 1.1中定义的 GenAISys 架构，图2.1则进一步展示了 GenAISys 的底层功能。

We’ll continue to implement the architecture of GenAISys as we’ve defined in Figure 1.1 from Chapter 1. Figure 2.1, on the other hand, takes us further into the underlying functions of a GenAISys.

图 2.1：定义要构建的函数

Figure 2.1: Defining the functions to build

我们在前一章中已经确定，人类的角色至关重要，前面的图表也印证了这一点。无论构建模块（模型或框架）多么先进，我们都是全人类人工智能系统的核心。我们的首要任务是运用人类的创造力进行设计，以找到……如何有效地实现 GenAISys 控制器？GenAISys 需要人类的创造力、判断力和技术决策能力。像 ChatGPT、Gemini 和 Microsoft Copilot 这样的无缝辅助驾驶系统背后，隐藏着错综复杂的 AI 和非 AI 逻辑层。如果我们想要构建自己的类似 ChatGPT 的系统，就必须依靠人类来完成这些繁重的工作！

We established in the previous chapter that human roles are essential, and the preceding figure acknowledges that fact. We are the core of a GenAISys, no matter how advanced the building blocks (models or frameworks) are. Our first task is designing using our human creativity to find effective ways to implement a GenAISys controller. GenAISys needs human creativity, judgment, and technical decision-making. Under the hood of seamless copilots such as ChatGPT, Gemini, and Microsoft Copilot lie intricate layers of AI and non-AI logic. If we want to build our own ChatGPT-like system, we humans need to do the heavy lifting!

我们将开发两个独立的程序：

We will build two separate programs:

• 一个实现的对话代理GPT-4o 支持短期记忆和长期记忆，这将有助于我们在多次交流中增强情境感知能力。它与图 2.1中的功能F3相符。
• A conversational agent implemented with GPT-4o, which supports both short- and long-term memory. This will help us enforce contextual awareness across multiple exchanges. It aligns with function F3 in Figure 2.1.
• 一个人工智能控制器协调器，它将同时使用 GPT-4o 分析用户输入，搜索指令库，用适当的指令补充输入，并运行指令中的函数。
• An AI controller orchestrator that will also use GPT-4o to analyze the user input, search a library of instructions, augment the input with the appropriate instructions, and run the function(s) in the instructions.

本章我们将重点讨论两种场景：情感分析和语义（硬科学）分析，它们分别对应于我们架构中的函数F1和F2 。函数F4和F5将在第三章中添加。

In this chapter, we’ll focus on two scenarios: sentiment analysis and semantic (hard science) analysis, which correspond to functions F1 and F2 in our architecture. Functions F4 and F5 will be added in Chapter 3.

尽管这些示例是为 OpenAI 的 API 构建的，其逻辑与模型无关。一旦您理解了它的工作原理，就可以修改代码以使用任何 LLM（逻辑学习模型），例如 Meta 的 Llama、xAI 的 Grok、Google 的 Gemini 或 Cohere。

Although these examples are built for OpenAI’s API, the logic is model-agnostic. Once you understand how it works, you can adapt the code to use any LLM—such as Meta’s Llama, xAI’s Grok, Google’s Gemini, or Cohere.

一旦我们分别构建了对话代理和控制器协调程序，我们将把它们合并成一个统一的智能 AI 控制器，如图2.2所示。

Once we’ve built the conversational agent and controller orchestrator programs separately, we will merge them into a unified intelligence AI controller, as shown in Figure 2.2.

图 2.2：后续步骤——通过 Pinecone 向量存储集成 AI 控制器功能

Figure 2.2: Next steps—integrating the AI controller functions through a Pinecone vector store

目前，我们需要专注于分别构建每个组件，以便充分了解它们的行为。一旦基础搭建完成，我们将在第三章中通过 Pinecone 向量存储将它们合并起来。现在，让我们直接进入代码编写阶段，开始开发对话代理。

For now, we need to focus on building each component individually so we can fully understand their behavior. Once that foundation is in place, in Chapter 3, we will merge them through a Pinecone vector store. Let’s now dive straight down into code and begin developing the conversational agent.

对话式人工智能代理

Conversational AI agent

我们俩本节的主要目标是构建一个具备以下功能的对话式人工智能代理：

Our two primary goals for this section are to build a conversational AI agent with the following:

• 用户需要具备短期记忆能力，才能完整地完成类似 ChatGPT 的对话循环。代理人可以进行任意次数的交流；他们之间的互动次数没有限制。
• Short-term memory retention for a full ChatGPT-like conversational loop. The user and agent can have as many exchanges as they wish; there is no limit to the number of interactions between them.
• 跨多个用户和会话的长期记忆保持。我们将把数据存储在内存中。会话将信息持久化到内存存储（在本例中为文本文件）。这将使 John、Myriam 和 Bob 等用户能够感知多用户上下文。我们的对话代理将超越传统的 ChatGPT 式一对一对话，转向能够处理多会话、多用户交互的定制化 GenAISys 系统。
• Long-term memory retention across multiple users and sessions. We’ll store in-memory sessions and persist them to a memory storage (in this case, a text file). This will enable multi-user contextual awareness for users such as John, Myriam, and Bob. Our conversational agent will move beyond classic one-to-one ChatGPT-style dialogues toward a custom GenAISys capable of handling multi-session, multi-user interactions.

首先，打开Conversational_AI_Agent.ipynb本章的 GitHub 目录（https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main）。本笔记本将指导您完成环境设置。

To get started, open Conversational_AI_Agent.ipynb in this chapter’s GitHub directory (https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main). This notebook will guide you through the environment setup.

建立环境

Setting up the environment

我们将重复使用上一章已经介绍过设置过程。如果您需要回顾一下，可以随时查看该部分。首先，请安装 OpenAI 并下载所需文件：

We’ll reuse the setup process from the previous chapter. If you need a refresher, feel free to revisit that section. Start by installing OpenAI and downloading the required files:

!curl -L https://raw.githubusercontent.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/master/commons/grequests.py --output grequests.py
from grequests import download
download("commons","requirements01.py")
download("commons","openai_setup.py")
download("commons","openai_api.py")

我们还需要下载两个额外的函数来构建我们的对话代理：

We’ll also need to download two additional functions to build our conversational agent:

• download("commons","conversational_agent.py")：这包含了管理完整对话循环和记忆对话的功能。
• download("commons","conversational_agent.py"): This contains the functions to manage a full-turn conversation loop and memorize the dialogue.
• download("commons", "processing_conversations.py")该模块包含用于加载、显示和清理历史对话的工具，旨在提升对话代理在多个会话和用户间的记忆跨度。这种自定义的多会话、多用户功能超越了标准 ChatGPT 类辅助代理的功能范围。
• download("commons", "processing_conversations.py"): This contains tools to load, display, and cleanse past conversations to increase the memory span of the conversational agent across several sessions and users. This custom multisession, multi-user feature goes beyond the scope of standard ChatGPT-like copilots.

现在让我们继续实现 中的函数conversational_agent.py，我们将在与对话式 AI 代理的整个会话过程中调用这些函数。

Let’s now move on to implementing the functions in conversational_agent.py, which we’ll call throughout our sessions with the conversational AI agent.

对话式人工智能代理工作流程

Conversational AI agent workflow

对话AI代理包含两个主要部分：

The conversation AI agent contains two main parts:

• 开始初始对话，与人工智能代理展开对话。
• Starting the initial conversation to initiate a dialogue with the AI agent
• 运行完整的对话循环，即可与人工智能代理进行任意次数的内存对话，满足用户的需求。每次会话结束后，对话内容都会被保存，以便稍后由同一用户或其他用户继续进行。
• Running the full-turn conversation loop to continue as many in-memory exchanges as a user wishes with the AI agent. At the end of each session, the dialog is saved so it can be resumed later—by the same user or another.

开始初步对话

Starting the initial conversation

最初的对话标志着新会话的开始。它由人工智能控制器处理，如图 2.3所示。

The initial conversation marks the entry point for a new session. It’s handled by the AI controller and illustrated in Figure 2.3.

图 2.3：初始对话控制器

Figure 2.3: The initial conversation controller

我们将逐一分析与生成式人工智能模型进行初始对话的每个步骤，以详细了解类似 ChatGPT 的小型对话代理的工作原理。这 10 个步骤从“开始”开始。

We will go through each step of the initial conversation with the generative AI model to understand in detail how a small-scale ChatGPT-like conversational agent works. The 10-step process begins with Start.

1. 开始对话

1. Starting the conversation

这程序从这个入口点开始，通过run_conversational_agent函数 `in` 调用，该函数将在笔记本中由 `s`及其参数openai_api.py调用：conversational_agent

The program begins at this entry point through the run_conversational_agent function in openai_api.py, which will be called in the notebook by conversational_agent and its parameters:

# Start the conversational agent
def run_conversational_agent(
    uinput, mrole, mcontent, user_role, user_name
):
    conversational_agent(uinput, mrole, mcontent, user_role, user_name)

参数在这种情况下，对话代理将处理以下内容：

The parameters the conversational agent will process in this case are the following:

• uinput：包含输入（用户或系统），例如，Where is Hawaii?。
• uinput: Contains the input (user or system), for example, Where is Hawaii?.
• mrole：定义消息的角色。它可以是user或system。您还可以分配 API 将解释的其他角色，例如定义 AI 的角色，例如You are a geology expert。
• mrole: Defines the role of the message. It can be user or system. You can also assign other roles that the API will interpret, such as defining the AI’s persona, for example, You are a geology expert.
• mcontent：例如，这是我们期望系统应该有的样子You are a geology expert。
• mcontent: Is what we expect the system to be, for example, You are a geology expert.
• user_role：定义用户的角色，例如，user。
• user_role: Defines the role of the user, for example, user.
• user_name例如，用户名John。
• user_name: The name of the user, for example, John.

2-3. 初始化 API 变量和消息对象

2–3. Initializing API variables and the messages object

messages_obj已初始化根据上一步所述的对话参数，开始对话：

messages_obj is initialized with the parameters of the conversation described in the previous step, Starting the conversation:

messages_obj = [{"role": mrole, "content": mcontent}]

messages_obj正在集中精力该对象存储在系统内存中。只要与 GPT-4o 模型进行会话交流，该对象就会被添加到内存中。它将用于记录会话之间的对话。第一条消息包含用于设置代理上下文的角色和内容。

messages_obj is focusing on the memory of the system. This object will be appended as long as the session lasts with the exchanges with the GPT-4o model. It will be used to log conversations between sessions. The first message contains the role and content for setting up the agent’s context.

4. 打印欢迎信息

4. Printing a welcome message

系统现在已准备好与用户互动。代理首先会显示欢迎信息，并说明对话结束后如何退出系统：

The system is now ready to interact with users. The agent first displays a welcome message and explains how to exit the system once the conversation is over:

print("Welcome to the conversational agent! Type 'q' or 'quit' to end the conversation.")

5. 处理初始用户输入

5. Handling the initial user input

用户的初始输入会被添加到messages_obj代理的内存中，以便为其提供内存和信息。代理程序需要遵循的方向。初始用户输入将由对话代理程序发送：

The user’s initial input is added to messages_obj to provide the agent with memory and provide the direction the agent is expected to follow. The initial user input will be sent from the conversational agent:

if initial_user_input:
    print(f"{user_name}: {initial_user_input}")
    messages_obj.append(
        {"role": user_role, "content": initial_user_input}
    )

6. 清理初始对话记录

6. Cleansing the initial conversation log

messages_obj以结构化格式保存对话历史记录。对于某些操作，在我们的应用程序中，例如生成简化显示、创建合并日志条目或为基于文本的函数准备输入时，我们需要将结构化日志转换为单个连续字符串。这可以确保数据格式符合这些特定任务的要求，并有助于解决合并不同消息部分时可能出现的任何标点符号或格式问题：

messages_obj holds the conversation’s history in a structured format. For certain operations within our application, such as generating a simplified display, creating a consolidated log entry, or preparing input for a text-based function, we need to convert this structured log into a single, continuous string. This makes sure that the data is in the correct format for these specific tasks and helps resolve any potential punctuation or formatting quirks that might arise when combining the different message parts:

conversation_string = cleanse_conversation_log(messages_obj)

清理函数会清理对话并返回一个字符串：

The cleansing function cleans the conversation and returns a string:

def cleanse_conversation_log(messages_obj):
  conversation_str = " ".join(
        [f"{entry['role']}: {entry['content']}" for entry in messages_obj]
    )
    # Remove problematic punctuations
    return re.sub(r"[^\w\s,.?!:]", "", conversation_str)

7. 发起初始 API 调用

7. Making the initial API call

清洗后的对话字符串被发送到 API 进行处理。API 会提供一个基于此的响应。系统会记录上次输入内容和对话历史记录。现在系统具备记忆功能：

The cleansed conversation string is sent to the API for processing. The API provides a response based on the last input and the conversation history. The system now has a memory:

agent_response = make_openai_api_call(
    input=conversation_string,
    mrole=mrole,
    mcontent=mcontent,
    user_role=user_role
)

8. 附加初始 API 响应

8. Appending the initial API response

这助手从 API 返回的响应将被处理并附加到系统中messages_obj。我们正在不断增加系统的内存，从而提升其上下文感知能力：

The assistant’s response from the API is processed and appended to messages_obj. We are continuing to increase the system’s memory and, thus, its contextual awareness:

messages_obj.append({"role": "assistant", "content": agent_response})

9. 显示初始助手的响应

9. Displaying the initial assistant’s response

该系统的系统会显示响应结果供用户分析，并决定是继续还是退出会话：

The system’s response is displayed for the user to analyze and decide whether to continue or exit the session:

print(f"Agent: {agent_response}")

10. 开始对话循环

10. Starting the conversation loop

这系统现在进入对话循环，可以进行多轮对话，直到用户决定退出会话为止：

The system now enters the conversation loop, where multiple dialogue turns can take place until the user decides to exit the session:

while True:
    user_input = input(f"{user_name}: ")
    if user_input.lower() in ["q", "quit"]:
        print("Exiting the conversation. Goodbye!")
        break

现在我们准备开始一个完整的对话循环。

We are now ready to begin a full-turn conversation loop.

完整的对话循环

The full-turn conversation loop

这初始对话现已启动。我们将从步骤 11开始进入完整的对话循环，如图2.4所示。

The initial conversation is now initialized. We will enter the full-turn conversation loop starting from step 11 onward, as illustrated in Figure 2.4.

图 2.4：从步骤 11 开始的对话循环

Figure 2.4: The conversation loop starting from step 11

11. 提示用户输入

11. Prompting for the user input

这对话延续初始对话，并通过messages对象进行记忆。用户提示会触发完整的对话循环。第一步是输入用户名。这种自定义方式超越了标准 ChatGPT 类对话代理的局限，后者每个会话仅限一个用户。我们正在初始化一个多用户对话：

The conversation continues the initial dialogue and is memorized through the messages object. The user prompt triggers a full-turn conversation loop. The first step is to enter the user’s name. This custom takes us beyond the standard ChatGPT-like conversational agents that are limited to one user per session. We are initializing a multi-user conversation:

user_input = input(f"{user_name}: ")

12. 检查出口条件

12. Checking the Exit condition

如果q或quit​输入后，会话结束：

If q or quit is entered, the session is ended:

if user_input.lower() in ["q", "quit"]:
    print("Exiting the conversation. Goodbye!")
    break

13. 将用户输入附加到消息对象

13. Appending the user input to the messages object

这系统现在配备了完整对话循环的记忆功能。它使用我们定义的通用 API 格式。用户的输入会附加到messages_obj：

The system is now equipped with a memory of a full-turn conversation loop. It uses the generic API format we defined. The user’s input is appended to messages_obj:

messages_obj.append({"role": user_role, "content": user_input})

14. 清理对话记录（循环）

14. Cleansing the conversation log (loop)

这更新后的数据messages_obj会进行清理，以确保其符合 API 调用要求，如步骤 6所述，清理初始对话日志：

The updated messages_obj is cleansed to make sure it complies with the API calls, as in step 6, Cleansing the initial conversation log:

conversation_string = cleanse_conversation_log(messages_obj)

15. 在对话循环中进行 API 调用

15. Making the API call in the conversation loop

在在这个完整的对话循环中，整个对话都会发送到 API。API 将根据整个对话的上下文和新的输入返回响应：

In this full-turn conversation loop, the whole conversation is sent to the API. The API will thus return a response based on the context of the whole conversation and the new input:

agent_response = make_openai_api_call(
    input=conversation_string,
    mrole=mrole,
    mcontent=mcontent,
    user_role=user_role
)

16. 在对话循环中附加 API 响应

16. Appending the API response in the conversation loop

这messages_objAPI 的响应会在每次对话回合中附加到后面：

The API’s response is appended to messages_obj at each conversation turn:

messages_obj.append({"role": "assistant", "content": agent_response})

17. 显示助手的回应

17. Displaying the assistant’s response

这API响应会在循环中的每次对话回合显示：

The API response is displayed at each conversation turn in the loop:

print(f"Agent: {agent_response}")

18. 退出并保存对话记录

18. Exiting and saving the conversation log

当用户退出循环时，对话内容会被保存。此功能将模拟类似 ChatGPT 的功能。一个能够保存同一用户两次会话之间对话的平台。然而，由于在“运行对话代理”部分，我们将看到，在对话代理的实现过程中，我们的程序能够保存团队成员之间对话的多用户会话：

When a user exits the loop, the conversation is saved. This feature will replicate a ChatGPT-like platform that can save dialogue between two sessions with the same user. However, as we will see in our implementation of a conversational agent in the Running the conversational agent section, our program will be able to save a multi-user session in a conversation between team members:

with open("conversation_log.txt", "w") as log_file:
    log_file.write("\n".join([f"{(user_name if entry['role'] == 'user' else entry['role'])}: {entry['content']}" for entry in messages_obj]))

19. 结束

19. End

这对话代理在记住对话内容后终止会话：

The conversational agent terminates the session after memorizing the conversation:

print("Conversation saved to 'conversation_log.txt'.")

我们已经探索了对话代理的功能。

We have explored the conversational agent’s functionality.

现在，让我们继续讨论代表人工智能控制器的AI对话代理程序。

Now, let’s move on to the AI conversational agent program that represents an AI controller.

运行对话式人工智能代理

Running the conversational AI agent

主程序Conversational_AI_Agent.ipynb从调用必要的函数conversational_agent.py到处理人工智能交互。我们将通过三个用户会话来模拟以下场景：

The main program, Conversational_AI_Agent.ipynb, calls the necessary functions from conversational_agent.py to handle AI interactions. We will be running a conversation through three user sessions with this scenario:

1. 约翰首先与对话式人工智能代理进行短期记忆训练。
1. John begins with a short-term memory session with the conversational AI agent.
2. 会话结束后，约翰的对话内容将被保存到日志文件中。
3. John’s conversation will be saved in a log file when the session is over.
4. Myriam 使用同一个日志文件恢复会话。
5. Myriam resumes the session using that same log file.
6. 会话结束后，Myriam 的对话将与 John 的对话保存在同一个日志文件中。
7. Myriam’s conversation will be saved in the same log file as John’s when the session is over.
8. 鲍勃将接替约翰和米里亚姆的工作。
9. Bob will pick up where John and Myriam left off.
10. 会话结束后，鲍勃的对话将与约翰和米里亚姆的对话保存在同一个日志文件中。
11. Bob’s conversation will be saved in the same log file as John’s and Myriam’s when the session is over.

这三位用户在连续的会话中进行交互。在第三章中，我们将通过对用户进行分组来进一步探讨这个问题。我们使用 Pinecone 向量存储，以便多个用户可以实时参与同一会话。现在，让我们逐步了解这种多用户设置，看看对话式 AI 代理如何处理这些会话。首先，我们来看第一步：John 的短期记忆会话。

All three users interact in successive sessions. In Chapter 3, we’ll go further by grouping users through a Pinecone vector store so that multiple users can participate together in a session in real time. For the moment, let’s walk through this multi-user setup step by step and see how the conversational AI agent handles these sessions. Let’s begin with the first step: John’s short-term memory session.

短期记忆会话

Short-term memory session

这会话开始时，会使用对话代理步骤 1“开始对话”中描述的参数：

The session begins with the parameters described in step 1, Starting the conversation, of the conversational agent:

uinput = "Hawai is on a geological volcano system. Explain:"
mrole = "system"
mcontent = "You are an expert in geology."
user_role = "user"

我们还会像在 ChatGPT 会话中那样添加用户名：

We are also adding the name of the user like in a ChatGPT-like session:

user_name = "John"

正是这一简单的改进，user_name使我们的 GenAISys 超越了标准的 ChatGPT 类平台。它允许我们将记忆与特定用户关联起来，并在单个系统中扩展到多用户对话。

This simple addition—user_name—is what takes our GenAISys beyond standard ChatGPT-like platforms. It allows us to associate memory with specific users and expand into multi-user conversations within a single system.

现在我们将导入第一个函数，即 OpenAI API 功能，以便向 OpenAI 的 API 发出请求，如第 1 章所述：

We will now import the first function, the OpenAI API functionality, to make a request to OpenAI’s API, as described in Chapter 1:

from openai_api import make_openai_api_call

程序现在导入第二个函数，即对话代理，并按照本节前面所述的方式运行它：

The program now imports the second function, the conversational agent, and runs it as described earlier in this section:

from conversational_agent import run_conversational_agent
run_conversational_agent(uinput, mrole, mcontent, user_role,user_name)

让我们逐一了解用这两个函数实现的对话过程。首先，代理会欢迎我们：

Let’s go through each step of the dialog implemented with our two functions. The agent first welcomes us:

Welcome to the conversational agent! Type 'q' or 'quit' to end the conversation.

第一个用户约翰询问有关夏威夷地质的解释：

John, the first user, asks for a geological explanation about Hawaii:

John: Hawai is on a geological volcano system. Explain:

代理人给出了令人满意的答复：

The agent provides a satisfactory answer:

Agent: Hawaii is part of a geological volcanic system known as a "hotspot"…

约翰现在问起“那里”冲浪的事：

John now asks about surfing “there”:

John: Can we surf there?

谢谢由于我们已将记忆功能内置于智能体中，它现在通过记忆保留具备了情境感知能力。智能体能够正确回答有关在夏威夷冲浪的问题：

Thanks to the memory we built into the agent, it now has contextual awareness through memory retention. The agent correctly responds about surfing in Hawaii:

Agent: Yes, you can definitely surf in Hawaii! The Hawaiian Islands are renowned …

约翰现在询问最佳住宿地点，但没有提到夏威夷：

John now asks about the best places to stay without mentioning Hawaii:

John: Where are the best places to stay?

智能体利用上下文感知能力给出了正确的答案：

The agent answers correctly using contextual awareness:

Agent: Hawaii offers a wide range of accommodations …

约翰随后退出了会议：

John then quits the session:

John: quit

代理退出对话并将对话内容保存到对话日志中：

The agent exits the conversation and saves the dialogue in a conversation log:

Agent:Exiting the conversation. Goodbye!
Conversation saved to 'conversation_log.txt'.

短期会话结束了，但得益于记忆保留功能conversation_log.txt，我们可以轻松地从约翰中断的地方继续对话。因此，我们可以立即或稍后继续对话，利用conversation_log.txt自动生成的文件提供的记忆保留功能。

The short-term session ends, but thanks to memory retention via conversation_log.txt, we can easily pick up from where John left off. We can thus continue the dialogue immediately or at a later time, leveraging memory retention through the conversation_log.txt file that was automatically generated.

长期记忆会话

Long-term memory session

这短期会话已保存。我们有三个选项：

The short-term session is saved. We have three options:

• 立即停止程序。这样一来，conversation_log.txt程序将只包含约翰的会话，您可以选择继续或停止该会话。
• Stop the program now. In this case, conversation_log.txt will only contain John’s session, which can be continued or not.
• conversation_log.txt决定为下一个用户 Myriam初始化一个单独的帐户。
• Decide to initialize a separate conversation_log.txt for the next user, Myriam.
• 继续进行多用户会话，将 John 的对话加载到 Myriam 的初始对话上下文中。
• Continue with a multi-user session by loading John’s conversation into Myriam’s initial dialog context.

本章程序选择继续采用多会话、多用户场景。

The program in this chapter chooses to continue a multi-session, multi-user scenario.

继续与约翰对话的第一步是使用以下方式加载并显示对话日志：processing_conversations.py我们在“设置环境”部分下载了该函数。现在，我们导入并运行该函数，以加载和显示对话日志：

The first step to continue the conversation with John is to load and display the conversation log using the function in processing_conversations.py that we downloaded in the Setting up the environment section. We now import and run the function that we need to load and display the conversation log:

from processing_conversations import load_and_display_conversation_log
conversation_log = load_and_display_conversation_log()

该功能是一个IPython使用 HTML 功能的标准流程，用于读取和显示对话：

The function is a standard IPython process using HTML functionality that reads and displays the conversation:

from IPython.core.display import display, HTML
import re
# Step 1: Load and Display Conversation Log
def load_and_display_conversation_log():
    try:
        with open("conversation_log.txt", "r") as log_file:
            conversation_log = log_file.readlines()
        # Prepare HTML for display
        html_content = "<h3>Loaded Conversation Log</h3><table border='1'>"
        for line in conversation_log:
            html_content += f"<tr><td>{line.strip()}</td></tr>"
        html_content += "</table>"
        # Display the HTML
        display(HTML(html_content))
        return conversation_log
    except FileNotFoundError:
        print("Error: conversation_log.txt not found. Ensure it exists in the current directory.")
        return []

输出结果显示了对话中的每个参与者，首先是系统的信息，然后是约翰的请求，最后是 GPT-4o 助手在每个回合的回应：

The output displays each participant in the conversation, beginning with the system’s information, followed by John’s request, and then the GPT-4o assistant’s response at each turn:

system: You are an expert in geology.
John: Hawai is on a geological volcano system. Explain:
assistant: Hawaii is part of a geological volcanic system…

添加为了将对话内容与下一个输入内容关联起来，我们将对其进行清理和准备。为此，我们依次导入cleanse_conversation_log和initialize_uinput从以下位置导入processing_conversations.py：

Before adding the conversation to the context of the next input, we will clean and prepare it. To achieve this, we successively import cleanse_conversation_log and import initialize_uinput from processing_conversations.py:

from processing_conversations import cleanse_conversation_log
from processing_conversations import initialize_uinput

然后，我们将调用之前定义的两个 Python 函数来清理数据，并准备新的输入：

Then, we will call the two Python functions that we defined to cleanse and then prepare the new input:

cleansed_log = cleanse_conversation_log(conversation_log)
nuinput = initialize_uinput(cleansed_log)

该cleanse函数会移除标点符号和可能存在问题的字符：

The cleanse function removes punctuation and potentially problematic characters:

# Step 2: Clean the conversation log by removing punctuations and special characters
def cleanse_conversation_log(conversation_log):
    cleansed_log = []
    for line in conversation_log:
        # Remove problematic punctuations and special characters
        cleansed_line = re.sub(r"[^\w\s,.?!:]", "", line)
        cleansed_log.append(cleansed_line.strip())
    return " ".join(cleansed_log)  # Combine all lines into a single string

最后，我们初始化新的输入：

Finally, we initialize the new input:

# Step 3: Initialize `uinput` with the cleansed conversation log to continue the conversation
def initialize_uinput(cleansed_log):
    if cleansed_log:
        print("\nCleansed conversation log for continuation:")
        print(cleansed_log)
        return cleansed_log  # Use the cleansed log as the new input
    else:
        print("Error: No data available to initialize `uinput`.")
        return ""

输出确认对话记录已被清除：

The output confirms that the conversation log has been cleansed:

Cleansed conversation log for continuation:
system: You are an expert in geology…

然后，输出结果确认其中nuinput包含对话日志，以便继续：

Then, the output confirms that nuinput contains the conversation log for continuation:

# `nuinput` now contains the cleansed version of the conversation log and can be used
print("\nInitialized `nuinput` for continuation:", nuinput)

接上节

现在我们可以继续约翰提出的关于情境感知记忆保持变量的讨论。我们将像之前一样，使用消息变量nuinput将情境添加到米里亚姆的请求中：nuinput

We can now continue the conversation that John began with nuinput as the memory retention variable for contextual awareness. We will add the context, nuinput, to Myriam’s request using the message variables as before:

ninput = nuinput+ "What about surfing in Long Beach"
mrole = "system"
mcontent = "You are an expert in geology."
user_role = "user"
user_name = "Myriam"

消息调用包含两个主要特征：

The message call contains two key features:

• ninput = nuinput+ [user input]这表明人工智能控制器现在拥有超越单次会话的长期记忆。
• ninput = nuinput+ [user input], which shows that the AI controller now has a long-term memory that goes beyond a single session
• user_name = "Myriam"这展示了多用户功能，证明我们定制的小型 ChatGPT 类 AI 控制器比标准副驾驶更灵活。
• user_name = "Myriam", which shows the multi-user feature, proving that our custom small-scale ChatGPT-like AI controller has more flexibility than a standard copilot

整个过程与约翰的情况相同。米里亚姆问了一个问题：

The overall process is the same as with John. Myriam asks a question:

Myriam: What about surfing in Long Beach

代理人回应：

The agent responds:

Agent:Long Beach, California, offers a different surfing experience compared to Hawai…

米里亚姆辞职了：

Myriam quits:

Myriam: quit

代理人确认对话已结束并保存到对话日志中：

The agent confirms that the conversation has ended and is saved to the conversation log:

Agent:Exiting the conversation. Goodbye!
Conversation saved to 'conversation_log.txt'.

AI控制器现在记录了John的会话以及Myriam继续该会话的过程。控制器可以进一步将另一位用户添加到对话中。

The AI controller now has a log of John’s session and Myriam’s continuation of the session. The controller can take this further and add yet another user to the conversation.

继续长期多用户内存

我们开始吧让鲍勃加入对话，继续进行。首先，再次显示对话记录：

Let’s add Bob to the mix to continue the conversation. First, display the conversation log again:

# Run the process
conversation_log = load_and_display_conversation_log()

你会看到约翰和米里亚姆的条目：

You’ll see entries for both John and Myriam:

system: You are an expert in geology.
Myriam: system: You are an expert …

然后，像之前一样，对日志进行清理，为下一轮对话做好准备。nuinput现在，日志中包含了约翰和米里亚姆的对话：

The log is then cleansed and prepared for the next turn of the conversation as previously. nuinput now contains John and Myriam’s sessions:

uinput =nuinput+ "Read the whole dialog then choose the best for geology research"
mrole = "system"
mcontent = "You are an expert in geology."
user_role = "user"
user_name = "Bob"

鲍勃专注于地质勘探任务，无暇顾及休闲娱乐：

Bob is focused on the geological mission, not leisure:

Bob:"Read the whole dialog then choose the best for geology research"

人工智能代理提供了准确的答案：

The AI agent provides an accurate response:

Agent: For geology research, the most relevant part of the dialogue is the explanation of Hawaii's geological volcanic system. This section provides detailed insights into the Hawaiian hotspot, mantle plumes, volcanic activity,…

随后，鲍勃退出了会话：

Bob then quits the session:

Bob: quit

代理人退出对话并将其保存到对话日志中：

The agent exits the conversation and saves it in the conversation log:

Agent:Exiting the conversation. Goodbye!
Conversation saved to 'conversation_log.txt'.

通过这三个场景，我们已经实现了一个由AI控制器管理的多用户全回合对话循环中的对话代理。接下来，我们来看看这个对话代理的后续步骤。

With these three scenarios, we have implemented a conversational agent managed by the AI controller in a multi-user full-turn conversational loop. Let’s examine the next steps for this conversational agent.

下一步

Next steps

至此，我们已经有了对话代理的基本架构。接下来需要将其集成到AI控制器编排器中。在开始构建AI控制器编排器之前，让我们先总结一下我们为对话代理所做的工作。

At this point, we have the basic structure of a conversational agent. We need to integrate it into an AI controller orchestrator. Let’s sum up the work we did for the conversational agent before beginning to build the AI controller orchestrator.

图 2.5：对话代理循环

Figure 2.5: The cycle of a conversational agent loop

如图所示在上图中，AI对话代理执行以下操作：

As illustrated in the preceding figure, the AI conversation agent does the following:

1. 代理处理输入（系统或人类用户）。
1. The agent processes the input (system or human user).
2. 代理人做出回应。
3. The agent responds.
4. 记忆保持功能已激活。
5. The memory retention function is activated.
6. 对话内容将作为上下文添加到后续输入中。
7. The conversation is added to the following input as context.
8. 用户可以退出。
9. The user can quit.

然而，目前的入口/出口机制尚不完善。我们可以进入和退出对话，但无法调用函数来协调诸如激活情感分析和语义分析之类的任务。为了完善AI控制器的架构，我们需要开始构建AI控制器协调器。

However, the entry/exit point is incomplete. We can enter and exit the conversation but cannot call functions to orchestrate tasks such as activating sentiment analysis and semantic analysis. To complete the architecture of the AI controller, we need to begin building the AI controller orchestrator.

AI控制器协调器

AI controller orchestrator

在本节中，我们将构建人工智能控制器协调器的第一个组件：选择能力。执行正确的任务。我们将此组件开发为一个独立组件，并从第 3 章开始集成。在第 3 章中，我们将通过 Pinecone 向量存储将对话代理与 AI 控制器协调器连接起来。

In this section, we will build the first component of our AI controller orchestrator: the ability to select the right task to perform. We develop this component as a standalone component that we will integrate starting from Chapter 3, where we will bridge the conversational agent with the AI controller orchestrator through a Pinecone vector store.

图 2.6展示了工作流程我们将开发的AI控制器协调器：

Figure 2.6 illustrates the workflow of the AI controller orchestrator we’ll be developing:

• C1. AI 控制器入口点输入触发该过程。
• C1. AI controller entry point input triggers the process.
• C2. 分析输入，输入可以是系统提示或用户提示。
• C2. Analyzes input, which could be a system or human user prompt.
• C3.通过 GPT-4o 的原生功能嵌入用户输入。
• C3. Embeds user input through GPT-4o’s native functionality.
• C4.通过 GPT-4o 的原生功能嵌入任务场景库。
• C4. Embeds task scenario repository through GPT-4o’s native functionality.
• C5. 选择与 输入最匹配的场景来执行任务。
• C5. Selects a scenario to execute a task that best matches the input.
• C6. 执行AI 控制器协调器选择的场景。
• C6. Executes the scenario selected by the AI controller orchestrator.

图 2.6：AI 控制器协调器的工作流程

Figure 2.6: Workflow of the AI controller orchestrator

我们将首先开发这个。该组件是使用 OpenAI 的 GPT-4o API 和 Python 实现的 AI 控制器编排器。此外，由于其理念是充分利用生成式 AI 模型的强大功能来执行 AI 控制器编排器请求的多个任务，因此我们将避免使用额外的库来增加编排器的负担，从而专注于 GenAISys 的架构。

We’ll develop this first component of the AI controller orchestrator with OpenAI’s GPT-4o API and Python. Additionally, since the idea is to leverage the full power of the generative AI model to perform several tasks requested by the AI controller orchestrator, we will thus avoid overloading the orchestrator with additional libraries to focus on the architecture of the GenAISys.

在本笔记本中，GPT-4o 将在程序中执行三个关键功能，如图2.7所示：

In this notebook, GPT-4o will perform three key functions in the program, as shown in Figure 2.7:

• 嵌入：GPT-4o它会系统地嵌入所有通过提示接收到的数据。输入数据在经过模型各层之前就已经被嵌入。在第 3 章中，我们将进一步探讨如何将可重用数据（例如指令场景）嵌入和插入到 Pinecone 向量存储中。
• Embedding: GPT-4o systematically embeds all the data it receives through a prompt. The input is embedded before going through the layers of the model. In Chapter 3, we will take this further by embedding and upserting reusable data such as instruction scenarios into a Pinecone vector store.
• 相似性搜索：GPT-4o可以执行相似性搜索并获得可靠的结果。GPT-4o 没有确定性的固定余弦相似度函数。它通过其复杂的神经网络学习理解关系，以一种更加细致、更不确定的方式模拟相似性判断。
• Similarity search: GPT-4o can perform a similarity search with reliable results. GPT-4o doesn’t have a deterministic fixed cosine similarity function. It learns to understand relationships through its complex neural network, mimicking similarity judgments in a much more nuanced, less deterministic way.
• 任务执行：一次选择场景后，GPT-4o 可以执行许多标准任务，例如情感分析和语义分析。
• Task execution: Once a scenario is chosen, GPT-4o can execute a number of standard tasks, such as sentiment and semantic analysis.

图 2.7：通过指令列表中的相似性搜索触发任务

Figure 2.7: Triggering tasks with similarity searches in a list of instructions

我们已经定义了协调器的工作流程和生成式人工智能模型的使用方法。但是，我们必须研究模型如何识别它需要执行的任务。

We have defined the workflow of the orchestrator and the generative AI model’s usage. However, we must examine how a model identifies the task it is expected to perform.

理解意图功能

Understanding the intent functionality

无论像 GPT-4o 这样的生成式人工智能模型多么强大，它也无法在没有用户反馈的情况下猜测用户想要什么。我们需要一个明确表达意图的提示。我们不能只是说“大峡谷是亚利桑那州一个很棒的旅游景点”，就指望模型能猜到我们想对这句话进行情感分析。我们必须明确地表达我们的意图，例如输入：“请对以下文本进行情感分析：大峡谷是亚利桑那州一个很棒的旅游景点。”

No matter how powerful a generative AI model such as GPT-4o is, it cannot guess what a user wants without a prompt that explicitly expresses intent. We cannot just say, “The Grand Canyon is a great place to visit in Arizona” and expect the model to guess that we want a sentiment analysis done on our statement. We have to explicitly formulate our intent by entering: “Provide a sentiment analysis of the following text: The Grand Canyon is a great place to visit in Arizona.”

为了解决人工智能控制器的意图问题，我们必须找到一个框架来协调它的行为。任务。一个好的起点是学习文本到文本转换转换器（T5），它是一个文本到文本的模型（Raffel et al., 2020）。T5 模型使用任务标签或任务特定的前缀来向转换器模型提供提示的意图。任务标签包含诸如摘要、翻译和分类之类的指令。如图 2.8所示，模型将检测标签并知道该做什么。

To resolve the issue of intent for an AI controller, we have to find a framework for it to orchestrate its tasks. A good place to start is to study the Text-to-Text Transfer Transformer (T5), which is a text-to-text model (Raffel et al., 2020). A T5 model uses task tags or task-specific prefixes to provide the intent of a prompt to the transformer model. A task tag contains instructions such as summarization, translation, and classification. The model will detect the tag and know what to do, as shown in Figure 2.8.

图 2.8：带有任务标签的 T5

Figure 2.8: T5 with task tags

训练 T5 模型需要在创建输入时显式添加任务标签，然后提供然而，OpenAI GPT 模型通过分析数十亿条包含指令和响应的语言序列（而非显式结构）来学习执行哪个任务。因此，使用类似 GPT 架构的生成式 AI 模型可以通过提示的上下文隐式地学习执行哪个任务。例如，一个解析良好的提示，例如“对以下文本进行情感分析：大峡谷是亚利桑那州一个很棒的旅游胜地。”，就包含了足够的上下文，GPT-4o 可以推断出所需的操作，而无需显式的标签。

Training a T5 model involves explicitly adding a task tag when creating an input and then providing the response. However, OpenAI GPT models learn which task to perform by analyzing billions of sequences of language, not explicit structures, that contain instructions and responses. A generative AI model using GPT-like architectures will thus learn which task to perform implicitly through the context of the prompt. For example, a well-parsed prompt such as “Provide a sentiment analysis of the following text: The Grand Canyon is a great place to visit in Arizona.” contains enough context for GPT-4o to infer the desired operation—without requiring an explicit tag.

让我们通过运行 T5 风格的示例来说明 GPT 模型的工作原理，GPT-4o 会隐式分析需要执行的任务。

Let’s illustrate how a GPT model works by running T5-style examples with GPT-4o’s implicit analysis of which task needs to be performed.

从T5到GPT模型

From T5 to GPT models

在本节中，我们将编写一个程序来展示 GPT-4o 如何解释指令——这是我们将要介绍的一项功能。利用我们编排器中的杠杆作用。目的是证明，尽管 GPT 式模型能够隐式推断意图，但它们仍然需要明确的指令。

In this section, we’ll write a program to show how GPT-4o interprets instructions—a capability we’ll leverage in our orchestrator. The aim is to demonstrate that, although GPT-style models infer intent implicitly, they still need clear instructions.

首先，打开GitHub 上的T52GPT.ipynb目录Chapter02。按照“对话式 AI 代理”部分的“设置环境”小节中的步骤设置环境，仅安装 OpenAI 环境：

We’ll begin by opening T52GPT.ipynb in the Chapter02 directory on GitHub. Set up the environment exactly as in the Setting up the environment subsection of the Conversational AI agent section, installing only the OpenAI environment:

download("commons","requirements01.py")
download("commons","openai_setup.py")
download("commons","openai_api.py")

无需额外安装。现在我们开始执行 CoLA 任务。

No additional installations are required. Let’s now begin with a CoLA task.

语言可接受性语料库（CoLA）

Corpus of Linguistic Acceptability (CoLA)

语言可接受性语料库（CoLA ）是一个公开的英语短句数据集，每个句子都经过标注。判断句子是否符合语法规则（语法正确）或不符合语法规则（语法错误）。通过对这些例子进行 GPT-4o 测试，我们可以证明高级语法能力。生成模型仅凭理解语言就能处理新任务，无需任何针对特定任务的微调。这意味着我们可以将先进的生成式人工智能模型应用于我们未曾训练过的各种任务。

The Corpus of Linguistic Acceptability (CoLA) is a public dataset of short English sentences, each tagged as acceptable (grammatical) or unacceptable (ungrammatical). By testing GPT-4o on these examples, we can show that advanced generative models can tackle new tasks purely by understanding language, without any task-specific fine-tuning. This means that we can apply advanced generative AI models to a wide range of tasks we didn’t train them for.

我们首先将以下输入提交给 GPT-4o 模型，看看在没有明确任务标签的情况下，它是否可以被接受：

Let’s first submit the following input to the GPT-4o model to see whether it is acceptable without an explicit task tag:

input="This aint the right way to talk."

我们将向系统提供最少的信息：

We will provide minimal information to the system:

mrole = "system"
user_role = "user"
mcontent = "Follow the instructions in the input"

我们还会使用本章一直使用的函数调用 OpenAI API：

We’ll also make an OpenAI API call with the function we have been using throughout this chapter:

# API function call
task_response = openai_api.make_openai_api_call(
    input,mrole,mcontent,user_role
)
print(task_response)

输出结果显示，即使是最强大的生成式人工智能模型，如果没有任务标签，也不知道该做什么：

The output shows that even one of the most powerful generative AI models doesn’t have a clue about what to do without a task tag:

I apologize if my previous response didn't meet your expectations. Please let me know how I can assist you better!

现在，让我们编写一条带有任务标签且消息内容相同的指令：

Now, let’s write an instruction with a task tag and the same message:

input="Is the following sentence gramatically correct:This aint the right way to talk."
mrole = "system"
user_role = "user"
mcontent = "Follow the instructions in the input"
# API function call
task_response = openai_api.make_openai_api_call(
    input,mrole,mcontent,user_role
)
print(task_response)

输入现在包含了对生成式人工智能模型预期结果的指示。输出结果现在准确无误：

The input now contains an indication of what is expected of the generative AI model. The output is now accurate:

The sentence "This aint the right way to talk." is not grammatically correct. The response corrects the sentence:
"This isn't the right way to talk."
Alternatively, if you want to maintain the informal tone, you could write:
"This ain't the right way to talk."
Note that "ain't" is considered informal and nonstandard in formal writing.

现在我们来执行一个翻译任务。

Let’s now perform a translation task.

翻译任务

Translation task

这项任务以自然语言表达的任务标签开头：

The task begins with a task tag that is expressed in natural language:

input=”Translate this sentence into French: Paris is quite a city to visit.”
mrole = “system”
user_role = “user”
mcontent = “Follow the instructions in the input”
# API function call
task_response = openai_api.make_openai_api_call(
    input,mrole,mcontent,user_role
)
print(task_response)

我们得到的结果是正确的：

The output we get is accurate:

Paris est vraiment une ville à visiter.

我们开始吧现在执行语义文本相似性基准测试（STSB）任务。

Let’s now perform a Semantic Textual Similarity Benchmark (STSB) task.

语义文本相似度基准（STSB）

Semantic Textual Similarity Benchmark (STSB)

STSB 式评分是 GenAISys AI 控制器的一项重要特性，该控制器依赖于相似性搜索来选择合适的指令场景、文档和其他资源。编曲家将依赖于这一点。能力。在接下来的测试中，我们将两个句子提交给模型，并要求它判断它们的语义相似度：

STSB-style scoring is an important feature for a GenAISys AI controller, which depends on similarity searches to pick the right instruction scenarios, documents, and other resources. The orchestrator will rely on this very capability. In the test that follows, we submit two sentences to the model and ask it to judge their semantic similarity:

input=”stsb:Sentence 1: This is a big dog. Sentence 2: This dog is very big.”
mrole = “system”
user_role = “user”
mcontent = “Follow the instructions in the input”
# API function call
task_response = openai_api.make_openai_api_call(
    input,mrole,mcontent,user_role)
print(task_response)

我们得到的结果是正确的：

The output we get is accurate:

The sentences "This is a big dog." and "This dog is very big." are semantically similar. Both sentences convey the idea that the dog in question is large in size. The difference in wording does not significantly alter the meaning, as both sentences describe the same characteristic of the dog.

当我们在数据集中查找与输入匹配的数据时，这个函数将非常有用。现在让我们运行一个摘要任务。

This function will prove to be very useful when we’re searching for data that matches the input in a dataset. Let’s now run a summarization task.

总结

Summarization

在根据输入，GPT-4o 可以检测到摘要指令标签，并能解释所需的最大响应长度：

In the following input, GPT-4o can detect the summarization instruction tag and also interpret the maximum length of the response required:

input="Summarize this text in 10 words maximum: The group walked in the forest on a nice sunny day. The birds were singing and everyone was happy."
mrole = "system"
user_role = "user"
mcontent = "Follow the instructions in the input"
# API function call
task_response = openai_api.make_openai_api_call(
    input,mrole,mcontent,user_role)
print(task_response)

输出结果再次准确无误：

The output is once again accurate:

Group enjoyed a sunny forest walk with singing birds.

要点本次探索的关键在于，无论我们实现哪种生成式人工智能模型，都需要任务标签才能按预期做出反应。接下来，我们将利用这一洞见，在任务标签处理协调器中实现语义文本相似性分析。

The takeaway of this exploration is that no matter which generative AI model we implement, it requires task tags to react as we expect. Next, we’ll use this insight to implement semantic textual similarity in our orchestrator for processing task tags.

实现指令选择的协调器

Implementing the orchestrator for instruction selection

在本节中，我们将开始构建基于任务标签的两条指令的编排器，如图 2.9所示：一条是情感分析指令，用于确定句子的情感；另一条是语义指令。分析，即分析句子中的事实。

In this section, we will begin building the orchestrator for two instructions based on task tags, as shown in Figure 2.9: sentiment analysis to determine the sentiment of a sentence and semantic analysis to analyze the facts in a sentence.

我们将通过要求生成式人工智能模型根据输入内容找到最佳任务标签方案（情感分析或语义分析）来增加系统的复杂性。换句话说，任务标签本身并不包含在输入内容中。我们将使用 GPT-4o 的语义文本相似性特征来自动选择合适的任务标签。

We will make the system more complex by asking the generative AI model to find the best task tag scenario (sentiment or semantic analysis) based on the input. In other words, the task tag will not be part of the input. We will use GPT-4o’s semantic textual similarity features to choose the right task tag itself.

图 2.9：运行带有隐式任务标签的任务

Figure 2.9: Running tasks with implicit task tags

环境设置与之前相同：

Setting up the environment is the same as earlier:

download("commons","requirements01.py")
download("commons","openai_setup.py")
download("commons","openai_api.py")

不编排器需要额外的安装。我们将首先实现指令场景选择功能。

No additional installations are required for the orchestrator. We will begin by implementing an instruction scenario selection.

选择场景

Selecting a scenario

人工智能控制器的核心在于决定在接收到输入（系统输入或用户输入）时应该执行什么操作。完成一项任务会开启一个充满各种可能方法的世界，我们将在本书中逐一探讨。然而，我们可以将它们分为两类：

The core of an AI controller is to decide what to do when it receives an input (system or human user). The selection of a task opens a world of possible methods that we will explore throughout the book. However, we can classify them into two categories:

• 使用明确的任务标签来触发指令。该标签可以是生成式人工智能模型中的上下文，并且可以在提示中以各种方式自由表达。
• Using an explicit task tag to trigger an instruction. This tag can be a context in a generative AI model and expressed freely in various ways in a prompt.
• 提示信息中没有任务指令，而是一个场景库，人工智能控制器将根据语义文本相似性从中做出决策。
• The prompt has no task instruction but instead a repository of scenarios from which the AI controller will make decisions based on semantic textual similarity.

接下来，我们将探讨第二种更主动的方法。我们将测试两个不带任何指令、任务标签，也没有任何关于生成式 AI 模型预期结果的提示。虽然我们稍后会实现其他带有任务标签的更明确的方法，但 GenAISys AI 控制器编排器必须能够在某些情况下主动应对。

Here, we’ll explore the second, more proactive approach. We’ll test two prompts with no instructions, no task tag, and no clue as to what is expected of the generative AI model. Although we will implement other, more explicit approaches later with task tags, a GenAISys AI controller orchestrator must be able to be proactive in certain situations.

• 第一个提示是对一部电影的看法，这意味着情感分析可能对用户有用：

  if prompt==1:
      input = "Gladiator II is a great movie although I didn't like some of the scenes. I liked the actors though. Overall I really enjoyed the experience."
  

• The first prompt is an opinion on a movie, implying that a sentiment analysis might interest the user:

  if prompt==1:
      input = "Gladiator II is a great movie although I didn't like some of the scenes. I liked the actors though. Overall I really enjoyed the experience."
  

• 第二个提示是一个事实，暗示用户可能对语义分析感兴趣：

  if prompt==2:
      input = "Generative AI models such as GPT-4o can be built into Generative AI Systems. Provide more information."
  

• The second prompt is a fact, implying that a semantic analysis might interest the user:

  if prompt==2:
      input = "Generative AI models such as GPT-4o can be built into Generative AI Systems. Provide more information."
  

为了使人工智能控制器具备决策能力，我们需要一个指令场景库。

To provide the AI controller with decision-making capabilities, we will need a repository of instruction scenarios.

定义任务/指令场景

Defining task/instruction scenarios

场景是存储在 GenAISys 存储库中的一系列指令。而类似 ChatGPT 的模型虽然GenAISys系统经过训练可以原生处理许多指令，但特定领域的用例需要定制场景（我们将从第5章开始深入探讨）。例如，GenAISys系统可能会收到类似这样的消息Customer order #9283444 is late。该消息可能与生产延迟或交付延迟有关。通过检查发件人的用户名和所属部门（生产部门或交付部门），AI控制器可以确定上下文，并选择相应的场景，做出相应的决策。

Scenarios are sets of instructions that live in a repository within a GenAISys. While ChatGPT-like models are trained to process many instructions natively, domain-specific use cases need custom scenarios (we’ll dive into these starting from Chapter 5). For example, a GenAISys could receive a message such as Customer order #9283444 is late. The message could be about a production delay or a delivery delay. By examining the sender’s username and group (production or delivery department), the AI controller can determine the context and, selecting a scenario, take an appropriate decision.

在这两种情况下，我们都首先创建一个结构化场景库（市场、情绪和语义分析）：

In both cases, we begin by creating a repository of structured scenarios (market, sentiment, and semantic analysis):

scenarios = [
    {
        "scenario_number": 1,
        "description": "Market Semantic analysis.You will be provided with a market survey on a give range of products.The term market must be in the user or system input. Your task is provide an analysis."
    },
    {
        "scenario_number": 2,
        "description": " Sentiment analysis  Read the content and classify the content as an opinion  If it is not opinion, stop there  If it is an opinion then your task is to perform a sentiment analysis on these statements and provide a score with the label: Analysis score: followed by a numerical value between 0 and 1  with no + or - sign.Add an explanation."
    },
    {
        "scenario_number": 3,
        "description": "Semantic analysis.This is not an analysis but a semantic search. Provide more information on the topic."
    }
]

我们还将添加一个包含相同场景的词典，其中包含场景的简单定义：

We will also add a dictionary of the same scenarios, containing simple definitions of the scenarios:

# Original list of dictionaries
scenario_instructions = [
    {
        "Market Semantic analysis.You will be provided with a market survey on a give range of products.The term market must be in the user or system input. Your task is provide an analysis."
    },
    {
        "Sentiment analysis  Read the content return a sentiment analysis on this text and provide a score with the label named : Sentiment analysis score followed by a numerical value between 0 and 1  with no + or - sign and  add an explanation to justify the score."
    },
    {
        "Semantic analysis.This is not an analysis but a semantic search. Provide more information on the topic."
    }
]

我们现在从字典中提取字符串并将它们存储在列表中：

We now extract the strings from the dictionary and store them in a list:

# Extract the strings from each dictionary
instructions_as_strings = [
    list(entry)[0] for entry in scenario_instructions
]

至此，我们的人工智能控制器已具备识别意图所需的一切——将任何传入的提示与最合适的场景进行匹配。

At this point, our AI controller has everything it needs to recognize intent—matching any incoming prompt to the best-fitting scenario.

执行意图识别和场景选择

Performing intent recognition and scenario selection

我们首先定义参数就像我们在“对话式人工智能代理”部分所做的那样，对对话式人工智能代理进行操作：

We first define the parameters of the conversational AI agent just as we did in the Conversational AI agent section:

# Define the parameters for the function call
mrole = "system"
mcontent = "You are an assistant that matches user inputs to predefined scenarios. Select the scenario that best matches the input. Respond with the scenario_number only."
user_role = "user"

编排器的任务是为任何给定的输入找到最佳任务，从而使人工智能控制器具有灵活性和适应性。在某些情况下，编排器可能决定不应用某个场景，而只是遵循。用户的输入。但在以下示例中，协调器将选择一个场景并应用它。

The orchestrator’s job is to find the best task for any given input, making the AI controller flexible and adaptive. In some cases, the orchestrator may decide not to apply a scenario and just follow the user’s input. In the following example, however, the orchestrator will select a scenario and apply it.

现在我们调整输入，以考虑编排器的请求：

We now adjust the input to take the orchestrator’s request into account:

# Adjust `input` to combine user input with scenarios
selection_input = f"User input: {input}\nScenarios: {scenarios}"
print(selection_input)

GPT-4o 现在将执行文本语义相似度搜索，就像我们在语义文本相似度基准测试 (STSB)部分中运行的那样。在这种情况下，它不仅执行纯文本比较，而且还将一个文本（用户输入）与一个文本列表（我们的场景描述）进行匹配：

GPT-4o will now perform a text semantic similarity search as we ran in the Semantic Textual Similarity Benchmark (STSB) section. In this case, it doesn’t just perform a plain text comparison, but matches one text (the user input) against a list of texts (our scenario descriptions):

# Call the function using your standard API call
response = openai_api.make_openai_api_call(
    selection_input, mrole, mcontent, user_role
)

用户输入如下：

Our user input is as follows:

User input: Gladiator II is a great movie

然后，选择场景：

Then, the scenario is chosen:

# Print the response
print("Scenario:",response )

然后选择场景编号，将其与相应的指令一起存储并显示：

The scenario number is then chosen, stored with the instructions that go with it, and displayed:

scenario_number=int(response)
instructions=scenario_instructions[scenario_number-1]
print(instructions)

以《角斗士2》为例，编排者正确地选择了情感分析场景：

For our Gladiator II example, the orchestrator correctly picks the sentiment analysis scenario:

{'Sentiment analysis  Read the content return a sentiment analysis on this text and provide a score with the label named : Sentiment analysis score followed by a numerical value between 0 and 1  with no + or - sign and  add an explanation to justify the score.'}

这自主任务选择这项功能——使 GenAISys 能够在没有明确标签的情况下选择合适的分析——将在实际部署中发挥至关重要的作用（参见第 5 章）。该程序现在使用生成式 AI 代理运行这些场景。

This autonomous task-selection capability—letting GenAISys choose the right analysis without explicit tags—will prove invaluable in real-world deployments (see Chapter 5). The program now runs the scenarios with the generative AI agent.

使用生成式 AI 代理运行场景

Running scenarios with the generative AI agent

现在AI 控制器已识别出正确的任务scenario_number，现在可以执行所选任务了。在本笔记本中，我们将逐步介绍该过程。首先，我们打印输入：

Now that the AI controller has identified the correct scenario_number, it’s time to execute the selected task. In this notebook, we’ll walk through that process step by step. We first print the input:

print(input)

利用该scenario_number值，我们可以从列表中访问场景描述instructions_as_strings：

Using the scenario_number value, we access the scenario description from our instructions_as_strings list:

# Accessing by line number (1-based index)
line_number = scenario_number
instruction = instructions_as_strings[line_number - 1]  # Adjusting for 0-based indexing
print(f"Instruction on line {line_number}:\n{instruction}")
mrole = "system"
user_role = "user"
mcontent = instruction

现在编排器已准备好运行情感分析。

The orchestrator is now ready to run a sentiment analysis.

情感分析

Sentiment analysis

我们附加对场景的描述原始用户提示并将组合请求发送给 GPT-4o：

We append the description of the scenario to the original user prompt and send the combined request to GPT-4o:

Instruction on line 2:
Sentiment analysis  Read the content return a sentiment analysis nalysis on this text and provide a score with the label named : Sentiment analysis score followed by a numerical value between 0 and 1  with no + or - sign and  add an explanation to justify the score.

# API function call
sc_input=instruction +" "+ input
print(sc_input)
task_response = openai_api.make_openai_api_call(
    sc_input,mrole,mcontent,user_role
)
print(task_response)

以《角斗士2》为例，响应可能如下所示：

For our Gladiator II example, the response might look like this:

Sentiment analysis score 0.75
The text expresses a generally positive sentiment towards the movie "Gladiator II." The use of words like "great movie," "liked the actors," and "really enjoyed the experience" indicates a favorable opinion. However, the mention of not liking some of the scenes introduces a slight negative element. Despite this, the overall enjoyment and positive remarks about the actors and the movie as a whole outweigh the negative aspect, resulting in a sentiment score leaning towards the positive side.

回应这表明编曲者找到了一个与输入匹配且能产生可接受输出的场景。现在，我们返回并更改提示，看看编排器是否能找到正确的场景。

The response shows that the orchestrator found a scenario that matches the input and produces an acceptable output. Now, let’s go back, change the prompt, and see whether the orchestrator finds the right scenario.

语义分析

Semantic analysis

目标现在要做的就是在不更改任何一行代码的情况下，验证编排器是否可以访问另一个场景。将依靠 GPT-4o 的原生能力来执行语义文本相似性搜索。

The goal now is to verify, without changing a single line of code, whether the orchestrator can access another scenario. The orchestrator will rely on GPT-4o’s native ability to perform semantic text similarity searches.

现在我们将激活提示符 2：

We will now activate prompt 2:

prompt=2
…
if prompt==2:
    input = "Generative AI models such as GPT-4o can be built into Generative AI Systems. Provide more information."

显然，此输入需要进行语义分析而非情感分析。因此，我们直接复用与情感分析搜索完全相同的代码：

This input clearly calls for a semantic analysis rather than sentiment analysis. We then reuse the exact same code as our sentiment analysis search:

# Accessing by line number (1-based index)
line_number = scenario_number
instruction = instructions_as_strings[line_number - 1]  # Adjusting for 0-based indexing
print(f"Instruction on line {line_number}:\n{instruction}")
mrole = "system"
user_role = "user"
mcontent = instruction

输出这表明已经找到了合适的方案：

The output shows that the right scenario was found:

Instruction on line 3:
Semantic analysis.This is not an analysis but a semantic search. Provide more information on the topic.

这项任务显示响应：

The task response is displayed:

print(task_response)

输出结果显示，协调器生成了连贯的语义分析：

The output shows that the orchestrator produces a coherent semantic analysis:

Generative AI models, like GPT-4, are advanced machine learning models designed to generate human-like text based on the input they receive….

这表明，在某些情况下，编排器无需任务标签即可找到合适的场景。这在处理更复杂的工作流程（例如高级生产和支持）时将非常有用。

This demonstrates that in some cases, the orchestrator will be able to find the right scenarios without task tags. This will prove useful when we tackle more complex workflows, such as advanced production and support.

概括

Summary

本章的首要要点是人类在全人类人工智能系统（GenAISys）中的核心作用。对话代理和编排器的创建都源于人类的设计。我们最初仅使用 OpenAI API 和 Python 开发这两个复杂的组件，但驱动我们定制版全人类人工智能系统的 AI 控制器的初始层级却是由我们人类设计的。全人类人工智能系统的基本原则始终适用：没有人类参与，就没有全人类人工智能系统。我们设计人工智能系统，实现它们，维护它们，并根据持续的反馈不断改进它们。

The first takeaway from this chapter is the central role of humans in a GenAISys. Human design drove the creation of both our conversational agent and orchestrator. We started developing these two complex components with simply an OpenAI API and Python, yet we humans designed the initial levels of the AI controller that powers our custom GenAISys. The basic GenAISys rule will always apply: no human roles, no GenAISys. We design AI systems, implement them, maintain them, and evolve them based on ongoing feedback.

第二个要点是，我们的对话式人工智能代理超越了类似 ChatGPT 的小规模结构。我们不仅构建了完整对话的短期上下文和记忆保持能力，还添加了跨多个用户和多个主题的长期记忆功能。我们的对话涉及三个用户（John、Myriam 和 Bob）和两个主题（地质学和冲浪）。随着本书的深入，我们将扩展这些多用户、多主题会话的范围，使其适用于团队协作至关重要的应用场景。

The second takeaway is how our conversational AI agent goes beyond a small-scale ChatGPT-like structure. We not only built short-term context and memory retention for a full-turn dialogue, but we also added long-term memory across multiple users and multiple topics. Our dialogue included three users (John, Myriam, and Bob) and two topics (geology and surfing). As we progress through the book, we will expand the scope of these multi-user, multi-topic sessions to use cases where team cooperation is essential.

第三个要点与我们的AI控制器编排器有关。我们给编排器提供了一个包含自定义指令的小型场景数据集，这些指令可以扩展到特定领域的用例，然后利用GPT-4o来选择合适的场景并执行任务本身。

The third takeaway concerns our AI controller orchestrator. We gave the orchestrator a small scenario dataset containing custom instructions that we can expand for a domain-specific use case, and then leveraged GPT-4o to both select the appropriate scenario and execute the task itself.

目前，我们已经拥有一个对话代理和一个初步的AI控制器编排器。当我们组装好AI控制器后，它们将共同构成一个独特的、多用户、多域的定制化GenAISys系统。为了构建这个多用户、多域的GenAISys AI控制器，我们将在下一章中构建一个Pinecone向量存储。

At this point, we have a conversational agent and a nascent AI controller orchestrator. When we assemble our AI controller, they will together form a unique multi-user, multi-domain customized GenAISys. To build our multi-user, multi-domain GenAISys AI controller, we will now build a Pinecone vector store in the next chapter.

问题

Questions

1. 类似 ChatGPT 的 GenAISys 只需要一个生成式 AI 模型，例如 GPT-4o。（正确或错误）
1. A ChatGPT-like GenAISys only needs a generative AI model such as GPT-4o. (True or False)
2. 类似 ChatGPT 的 GenAISys 不需要 AI 控制器。（正确或错误）
3. A ChatGPT-like GenAISys doesn’t require an AI controller. (True or False)
4. 在构建过程中，人的作用至关重要。d 正在运行 GenAISys。（正确或错误）
5. Human roles are critical when building and running GenAISys. (True or False)
6. 通常情况下（但并非总是如此），像 GPT-4o 这样的生成式人工智能模型会以某种形式包含任务标签。（正确或错误）
7. Generally, not always, a generative AI model such as GPT-4o contains a task tag in one form or the other. (True or False)
8. 有时（但并非总是如此），生成模型无需任务标签也能找到最有可能执行的任务。（正确或错误）
9. Sometimes, not always, a generative model can find the most probable task to perform without a task tag. (True or False)
10. GPT-4o 本身无法进行语义文本相似度分析。（正确或错误）
11. Semantic text similarity cannot be natively performed by GPT-4o. (True or False)
12. 使用 OpenAI API 实现完整的生成式 AI 对话循环需要编写代码。（正确/错误）
13. A full-turn generative AI conversation loop with an OpenAI API AI requires coding. (True or False)
14. 人工智能的长期记忆对话环节完全没有必要。（正确/错误）
15. Long-term memory AI conversation sessions are never necessary. (True or False)
16. GPT-40 只能用英语进行文本摘要。（正确或错误）
17. Summarizing a text can only be done in English by GPT-4o. (True or False)
18. 人工智能控制器协调器具有感知能力。（正确或错误）
19. An AI controller orchestrator is sentient. (True or False)

参考

References

• Raffel, C., Shazeer, N., Roberts, A., Lee, K., Narang, S., Matena, M., Zhou, Y., Li, W., & Liu, PJ (2020).使用统一的文本到文本转换器探索迁移学习的极限。https ://arxiv.org/abs/1910.10683
• Raffel, C., Shazeer, N., Roberts, A., Lee, K., Narang, S., Matena, M., Zhou, Y., Li, W., & Liu, P. J. (2020). Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer. https://arxiv.org/abs/1910.10683
• 任杰、孙宇、杜浩、袁伟、王超、王晓、周宇、朱志、王峰、崔松（2024）。生成式语义通信：架构、技术和应用。https ://doi.org/10.48550/arXiv.2412.08642
• Ren, J., Sun, Y., Du, H., Yuan, W., Wang, C., Wang, X., Zhou, Y., Zhu, Z., Wang, F., & Cui, S. (2024). Generative Semantic Communication: Architectures, Technologies, and Applications. https://doi.org/10.48550/arXiv.2412.08642

延伸阅读

Further reading

• Koziolek, H., Gruener, S., & Ashiwal, V. (2023). ChatGPT 用于 PLC/DCS 控制逻辑生成。https ://doi.org/10.48550/arXiv.2305.15809
• Koziolek, H., Gruener, S., & Ashiwal, V. (2023). ChatGPT for PLC/DCS Control Logic Generation. https://doi.org/10.48550/arXiv.2305.15809

订阅即可免费获取电子书

Subscribe for a Free eBook

新框架、演进的架构、研究成果发布、生产故障——AI_Distilled每周都会为从事 LLM 和 GenAI 系统实战的工程师和研究人员提供一份简报，帮您过滤掉各种干扰信息。立即订阅，即可免费获得电子书，以及每周更新的深度见解，助您保持专注，掌握最新资讯。

New frameworks, evolving architectures, research drops, production breakdowns—AI_Distilled filters the noise into a weekly briefing for engineers and researchers working hands-on with LLMs and GenAI systems. Subscribe now and receive a free eBook, along with weekly insights that help you stay focused and informed.

订阅请访问https://packt.link/TRO5B或扫描下方二维码。

Subscribe at https://packt.link/TRO5B or scan the QR code below.

3

3

将动态 RAG 集成到 GenAISys 中

Integrating Dynamic RAG into the GenAISys

一个可用于商业用途的生成式人工智能系统（GenAISys）需要具备灵活性，并能够应对人工智能市场快速发展的格局。人工智能控制器充当着电子营销、生产、存储、分发和支持等环节的自适应协调器，但为了满足如此广泛的任务需求，我们我们需要一个检索增强生成（RAG）框架。在前一章中，我们构建了一个对话式人工智能代理和一个用于生成式人工智能模型的指令场景相似性搜索函数（AI编排器）。在本章中，我们将增强这一基础，并在Pinecone索引中构建一个可扩展的RAG，以整合指令场景和经典数据，供生成式人工智能模型连接使用。

A business-ready generative AI system (GenAISys) needs to be flexible and ready to face the rapidly evolving landscape of the AI market. The AI controller acts as an adaptive orchestrator for e-marketing, production, storage, distribution, and support, but to satisfy such a range of tasks, we need a retrieval-augmented generation (RAG) framework. In the previous chapter, we built a conversational AI agent and a function for similarity search for instruction scenarios (AI orchestrator) for a generative AI model. In this chapter, we will enhance that foundation and build a scalable RAG in a Pinecone index to integrate both instruction scenarios and classical data, which the generative AI model will connect to.

为什么我们需要这种基于传统数据、动态自适应的 RAG 框架，并在此基础上构建向量化的指令场景？因为全球市场会对企业的内部和外部环境产生影响。例如，飓风可能导致电力短缺，危及企业的供应链。企业可能不得不迁移供应路线、生产或分销渠道。通用人工智能云平台或许能够完成部分工作，但更多时候，我们需要提供定制化的、特定领域的功能。因此，我们需要像 RAG 数据一样，在向量存储库中存储一套动态指令集。

Why do we need this dynamic and adaptive RAG framework with vectorized scenarios of instructions on top of classical data? Because the global market affects entities internally and externally. For example, a hurricane can cause electricity shortages, putting the supply chain of businesses in peril. Businesses might have to relocate supply routes, production, or distribution. General-purpose AI cloud platforms might do some of the job. But more often than not, we will need to provide custom, domain-specific functionality. For that reason, we need a dynamic set of instructions in a vector store repository as we do for RAG data.

我们将首先通过 Pinecone 索引定义生成式 AI 模型（在本例中为 GPT-4o）的架构场景驱动型任务执行。我们将仔细分析通过相似性搜索和检索为生成式模型构建智能场景的成本效益。我们将引入一个动态框架来生成类似 ChatGPT 的功能，并在后续章节中逐步介绍。

We will begin by defining the architecture scenario-driven task executions for a generative AI model, in this case, GPT-4o, through a Pinecone index. We will carefully go through the cost-benefits of investing in intelligent scenarios for the generative model through similarity search and retrieval. We will introduce a dynamic framework to produce ChatGPT-like capabilities that we will progressively introduce in the following chapters.

架构确定后，我们将首先构建一个 Pinecone 索引，用于对指令场景进行分块、嵌入和更新插入。我们将确保 GenAISys 向量存储能够嵌入查询并找到相关的指令场景。在第四章​​“构建 AI 控制器编排接口”中，我们将运用此功能来设计对话代理的界面和编排器。最后，我们将编写一个程序，将 RAG 环境中的经典数据更新插入到与指令场景相同的 Pinecone 索引中。我们将使用不同的命名空间来区分场景和经典数据。在本章结束时，我们将构建将指令链接到生成式 AI 模型的主要组件。我们将准备好在第四章中设计用户界面和 AI 控制器编排器。

Once the architecture is defined, we will first build a Pinecone index to chunk, embed, and upsert instruction scenarios. We will make sure the GenAISys vector store can embed a query and find a relevant instruction scenario. This capability will be a key component in Chapter 4, Building the AI Controller Orchestration Interface, when we design the conversational agent’s interface and orchestrator. Finally, we will write a program to upsert classical data in a RAG environment to the same Pinecone index alongside the instruction scenarios. Differentiation between scenarios and classical data will be maintained using distinct namespaces. By the end of this chapter, we will have built the main components to link instructions to a generative AI model. We will be ready to design a user interface and AI controller orchestrator in Chapter 4.

本章涵盖以下主题：

This chapter covers the following topics:

• 构建 RAG 架构以实现指令和数据的动态检索
• Architecting RAG for the dynamic retrieval of instructions and data
• 开发相似性搜索时收益递减规律
• The law of diminishing returns when developing similarity searches
• 考察混合型 GenAISys CoT 的架构
• Examining the architecture of a hybrid GenAISys CoT
• 通过分块、嵌入和插入指令场景创建 Pinecone 索引
• Creating a Pinecone index by chunking, embedding, and upserting instruction scenarios
• 利用经典数据增强松果指数
• Enhancing a Pinecone index with classical data
• 查询松果索引
• Querying the Pinecone index

我们的首要任务是构建一个用于动态检索的 RAG 框架。

Our first task is to architect a RAG framework for dynamic retrieval.

构建用于动态检索的 RAG 架构

Architecting RAG for dynamic retrieval

在此本节将定义一个 Pinecone 索引，用于存储指令场景和经典数据。这种结构使 GenAISys 能够实现动态且经济高效的检索：指令场景指导生成式 AI 模型（在本例中为 GPT-4o），而经典数据则为 RAG 流水线提供事实背景。

In this section, we will define a Pinecone index that stores both instruction scenarios and classical data. This structure gives GenAISys dynamic, cost-effective retrieval: the instruction scenarios steer the generative AI model (GPT-4o in our example), while the classical data supplies the factual context used by the RAG pipeline.

我们将逐一进行。以下组件：

We will go through the following components:

• 场景驱动的任务执行：设计优化的教学提示（“场景”），我们将把这些提示插入到 Pinecone 索引中。
• Scenario-driven task execution: Designing optimized instructional prompts (“scenarios”) that we will upsert to the Pinecone index.
• 成本效益策略：考虑收益递减规律，避免在自动化方面过度投资。
• Cost-benefit strategies: Considering the law of diminishing returns to avoid overinvesting in automation.
• 使用命名空间对 Pinecone 进行分区：使用 Pinecone 索引命名空间来明确区分指令场景和经典数据。
• Partitioning Pinecone with namespaces: Using Pinecone index namespaces to clearly differentiate instruction scenarios from classical data.
• 混合检索框架：实现隐式向量相似性搜索，同时触发生成式 AI 模型的显式指令（更多内容请参见场景驱动任务执行部分）。
• Hybrid retrieval framework: Implementing implicit vector similarity searches but also triggering explicit instructions for the generative AI model (more on this in the Scenario-driven task execution section).
• CoT循环：解释场景选择过程的灵活性如何导致循环在最终产生输出之前，生成式人工智能功能会不断迭代。
• CoT loops: Explaining how the flexibility of the scenario selection process will lead to loops of generative AI functions before finally producing an output.
• GenAISys 框架：为本书中我们将要构建的高级 GenAISys 框架奠定基础。
• GenAISys framework: Laying the groundwork for the advanced GenAISys framework we are building throughout the book.

我们先来深入了解一下场景驱动的任务执行。

Let’s first dive deeper into scenario-driven task execution.

场景驱动型任务执行

Scenario-driven task execution

在上一章中，我们看到了人工智能控制器选择下一步操作的两种互补方式：

In the previous chapter, we saw two complementary ways the AI controller can pick what to do next:

• 隐式选择：控制器嵌入用户提示，在其场景库中运行语义相似性搜索，并选择最接近的匹配项，而无需任何任务标签。这为我们提供了灵活、无需编写代码的编排方式（例如，它自动为《角斗士2》的评论选择了一个情感分析场景）。
• Implicit selection: The controller embeds the user’s prompt, runs a semantic similarity search across its scenario library, and chooses the closest match without any task tag. This gave us flexible, code-free orchestration (e.g., it automatically chose a sentiment-analysis scenario for the Gladiator II review).
• 明确选择：所需任务以明确的形式给出，可以是提示中的任务标签，也可以是用户界面操作，例如“运行网络搜索”。在这种情况下，控制器会跳过相似性搜索，直接跳转到请求的工具或工作流程。
• Explicit selection: The desired task is spelled out, either as a task tag in the prompt or as a user interface action, such as “Run web search.” Here, the controller skips the similarity search and jumps straight to the requested tool or workflow.

本章延续了同样的模式，但规模更大。我们不再管理少量精心挑选的提示，而是管理存储在向量数据库中的数百甚至数千个由专家编写的教学场景；我们不再支持单用户实验，而是支持多个并发用户和工作流程。这种场景驱动的（隐式）方法具有以下三个优势：

That same pattern continues in this chapter, but at a larger scale. Instead of a few hand-picked prompts, we manage hundreds or even thousands of expert-authored instruction scenarios stored in a vector database; instead of single-user experiments, we support many concurrent users and workflows. This scenario-driven (implicit) approach has three advantages:

• 这些高级提示/指导场景通常由专业人士创建，其专业水平往往超过主流用户。
• Professional experts typically create these advanced prompts/instruction scenarios, often surpassing the expertise level of mainstream users.
• 这些场景可以由人工智能专家和主题专家共同设计，涵盖公司从销售到交付的各种活动。
• The scenarios can be co-designed by AI specialists and subject-matter experts, covering a wide range of activities in a corporation, from sales to delivery.
• 场景的执行顺序由提示驱动，灵活且无序。这种动态方法避免了任务顺序的硬编码，从而最大限度地提高了适应性。
• The order of execution of the scenarios is prompt-driven, flexible, and unordered. This dynamic approach avoids hardcoding the order of the tasks, increasing adaptability as much as possible.

然而，虽然隐式任务规划能够最大限度地提高灵活性，但随着我们逐步构建可用于业务的系统，我们必须在灵活性和成本效益之间取得平衡。因此，在某些情况下，显式指令（例如通过选择用户界面中的选项来触发网络搜索）可以显著降低潜在成本，如图 3.1所示：

However, while implicit task planning maximizes flexibility, as we move toward building business-ready systems, we must balance flexibility with cost-efficiency. In some cases, therefore, explicit instructions, such as triggering a web search by selecting the option in the user interface, can significantly reduce the potential costs, as shown in Figure 3.1:

图 3.1：成本增加导致收益递减

Figure 3.1: Diminishing returns as costs increase

越多我们通过对 Pinecone 索引中的向量相似性进行搜索，来自动生成 AI 模型将要选择的隐式场景，而成本越高，这些场景就越容易被选择。为了控制成本，我们必须仔细考虑收益递减规律：

The more we automate implicit scenarios that the generative AI model will select with vector similarity searches in the Pinecone index, the higher the cost. To manage this, we must carefully consider the law of diminishing returns:

如图 3.1所示，该方程式（以理论单位表示）如下：

In this equation, as illustrated in Figure 3.1, in theoretical units, we have the following:

• 代表总体收益，当成本达到 50 时，收益大约为 15。
• represents the overall benefit, which is represented by roughly 15 when the cost reaches 50.
• 这代表了将指令场景存储在 Pinecone 索引中，并让生成式 AI 模型通过与用户输入的向量相似度来选择一个场景的初步益处。在这种情况下，收益几乎是成本的 1 倍。
• represents the initial benefit of storing instruction scenarios in the Pinecone index and asking the generative AI model to select one through vector similarity with the user input. In this case, it is nearly 1 benefit unit for 1 cost unit.
• 是指随着成本的增加，收益开始增加的速率。
• is the rate at which the benefit begins to increase as we increase the cost.
• 表示以理论单位（货币、人力资源或计算资源）衡量的成本。
• represents the cost measured in theoretical units (currency, human resources, or computational resources).
• 表示成本增加时收益递减的速度。
• denotes the rate at which returns diminish as cost increases.

例如，当成本达到7个理论单位时，收益也达到7个理论单位。这1单位成本产生单位收益是合理的。然而，当收益达到10单位时，成本可能会翻倍至14单位，这表明情况可能不妙。

For example, when the cost reaches 7 theoretical units, the benefit reaches 7 theoretical units. This 1 unit of cost generating 1 unit of benefit is reasonable. However, when the benefit reaches 10 units, the cost could double to 14 units, which signals that something is going wrong.

减少该因素具有强烈的负面影响通过平方成本计算收益：

The diminishing factor has a strong negative impact on the benefits through squared costs:

现在让我们来探讨一下我们如何在 Pinecone 索引中识别教学场景。

Let’s now explore how we identify instruction scenarios within a Pinecone index.

混合检索和CoT

Hybrid retrieval and CoT

我们的第一步是教会 GenAISys 框架清晰地区分经典数据和指令场景。为此，我们将在同一个 Pinecone 索引中使用两个命名空间来分离指令场景和数据，这两个命名空间分别命名为genai-v1：

Our first step is teaching the GenAISys framework to distinguish clearly between classical data and instruction scenarios. To achieve this, we will separate the instruction scenarios and the data with two namespaces within the same Pinecone index, named genai-v1:

• genaisys将包含信息指令向量
• genaisys will contain instruction vectors of information
• data01将包含信息的数据向量

  我们将在本章的“创建松果索引”genai-v1部分中用代码实现，并附上更多解释。

• data01 will contain data vectors of information

  We will implement genai-v1 in code with additional explanations in the Creating the Pinecone index section of this chapter.

一旦将 Pinecone 指数划分为场景和数据，我们就可以通过混合检索将 GenAISys 提升到另一个水平，如图3.2所示。

Once the Pinecone index has been partitioned into scenarios and data, we can take the GenAISys to another level with hybrid retrieval, as shown in Figure 3.2.

图 3.2：AI 控制器协调 GenAISys

Figure 3.2: AI controller orchestrating GenAISys

这混合检索框架前图中所示的启用 GenAISys 以执行以下操作：

The hybrid retrieval framework depicted in the preceding figure will enable GenAISys to do the following:

• 直接使用已处理、分块和嵌入式数据内存（参见图 3.2中的1-3 ）运行生成式 AI 模型，而无需经过 Pinecone 索引（参见3B）。例如，这将降低临时数据的成本。
• Run the generative AI model using processed, chunked, and embedded data memory (see 1–3 in Figure 3.2) directly without going through the Pinecone index (see 3B). This will reduce costs for ephemeral data, for example.
• 将分块和嵌入的数据插入到 Pinecone 索引后，运行生成式 AI 模型，可以将其作为场景中的一组指令，也可以作为经典数据。
• Run the generative AI model after the chunked and embedded data is upserted to the Pinecone index either as a set of instructions in a scenario or as classical data.
• 在 Pinecone 索引（参见3B）和生成式 AI 模型控制器（作为协调器）之间创建一个 CoT 循环。例如，模型的输出可以作为另一个 CoT 循环的输入，该循环将从 Pinecone 索引中检索场景或数据。类似 ChatGPT 的辅助工具通常会展示其输出，然后询问您是否想进一步探索——有时甚至会提供一些现成的后续提示供您点击。
• Create a CoT loop between the Pinecone index (see 3B) and the generative AI model controller as an orchestrator. For example, the output of the model can serve as input for another CoT cycle that will retrieve scenarios or data from the Pinecone index. ChatGPT-like copilots often present their output and then finish by asking whether you’d like to explore further—sometimes even suggesting ready-made follow-up prompts you can click on.

我们将在本章开始构建 GenAISys，并在接下来的几章中不断完善它。从第 4 章“构建 AI 控制器编排接口”开始，我们将使用这里介绍的 RAG 基础来开发如图 3.2所示的混合检索框架。我们构建的 GenAISys 将包含动态进程管理——这是跟上时代步伐的必要条件。市场环境不断变化。具体而言，我们的 GenAISys 将执行以下操作：

We’ll begin building our GenAISys in this chapter and continue refining it over the next few chapters. Starting from Chapter 4, Building the AI Controller Orchestration Interface, we’ll use the RAG foundations introduced here to develop the hybrid retrieval framework shown in Figure 3.2. The GenAISys we’re building will include dynamic process management—a requisite for keeping pace with the shifting market conditions. Specifically, our GenAISys will do the following:

• 利用 Pinecone 的矢量数据库或内存中的分块和嵌入式信息，通过相似性搜索来优化检索（指令或数据）。
• Leverage Pinecone’s vector database or in-memory chunked and embedded information with similarity searches to optimize retrieval (instructions or data)
• 明确触发直接指令，例如网络搜索，并将其包含在 CoT 循环中，以进行摘要、情感分析或语义分析。
• Explicitly trigger direct instructions, such as a web search, and include them in a CoT loop for summarization, sentiment analysis, or semantic analysis
• 将复杂的指令集和数据检索分解为可管理的步骤
• Break down complex sets of instructions and data retrieval into manageable steps
• 在生成输出之前，通过类似人类的思维过程迭代地改进解决方案。
• Iteratively refine solutions in a human-like thought process before producing an output
• 通过提供优化的指令场景，充分发挥生成式人工智能模型（包括 OpenAI 的推理模型，例如 o3）的性能。
• Get the best out of generative AI models, including OpenAI’s reasoning models such as o3, by providing them with an optimized instruction scenario

我们最初的本章的步骤是构建genai-v1Pinecone 索引，AI 控制器将使用该索引来管理genaisys命名空间内的指令场景。接下来，我们将演示如何将经典数据分块、嵌入和更新插入到data01命名空间中。让我们开始吧！

Our initial step in this chapter is building the genai-v1 Pinecone index, which the AI controller will use to manage instruction scenarios within the genaisys namespace. Then, we’ll demonstrate how to chunk, embed, and upsert classical data into the data01 namespace. Let’s get moving!

构建动态松果指数

Building a dynamic Pinecone index

我们将重点关注本文将介绍如何创建一个用于管理教学场景和经典数据的 Pinecone 索引。在接下来的章节中，我们将开始更新和插入教学场景以及经典数据。整个工作流程分为三个简单的阶段：

We’ll focus on creating a Pinecone index designed to manage both instruction scenarios and classical data. In the upcoming sections, we’ll begin upserting the instruction scenarios as well as classical data. The workflow breaks down into three straightforward stages:

• 为 OpenAI 和 Pinecone 设置环境。
• Setting up the environment for OpenAI and Pinecone
• 处理数据、分块，然后嵌入数据
• Processing the data, chunking it, and then embedding it
• 初始化松果索引
• Initializing the Pinecone index

打开Pinecone_instruction_scenarios.ipynbGitHub 上 Chapter03 目录下的 notebook 文件（https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main）。我们的首要任务是搭建环境。

Open the Pinecone_instruction_scenarios.ipynb notebook within the Chapter03 directory on GitHub (https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main). Our first task is to set up the environment.

建立环境

Setting up the environment

作为在本书中，我们将不断重用第 1 章和第2章中实现的功能和特性，为 Pinecone 添加新的功能和特性，并将安装内容组织成两部分：

As we move through the book, we will continually reuse functions and features implemented in Chapters 1 and 2, add new ones for Pinecone, and organize the installations into two parts:

• 使用与第 1 章相同的步骤安装 OpenAI 。如有需要，请参阅第 1 章。
• Installing OpenAI using the same process as in Chapter 1. Refer back to that chapter if needed.
• 为本章节及后续章节安装 Pinecone。
• Installing Pinecone for this and following chapters.

首先，下载grequests.py我们需要从GitHub 仓库中获取以下文件：

To begin, download the files we need by retrieving grequests.py from the GitHub repository:

!curl -L https://raw.githubusercontent.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/master/commons/grequests.py --output grequests.py

要安装 OpenAI，请按照第 1 章中的步骤操作。接下来我们将安装 Pinecone，本书后续章节中会用到它。

To install OpenAI, follow the same steps as in Chapter 1. We’ll move on to install Pinecone now, which we will refer to in upcoming chapters throughout the book.

安装松果

Installing Pinecone

下载Pinecone 需求文件包含了本书中要使用的 Pinecone 版本的使用说明。如果需要其他版本，则只需更新此文件即可：

Download the Pinecone requirements file that contains the instructions for the Pinecone version we want to use throughout the book. If another version is required, this will be the only file that needs to be updated:

download("commons","requirements02.py")

该文件包含安装函数，我们将使用以下命令调用该函数：

The file contains the installation function, which we will call with the following command:

# Run the setup script to install and import dependencies
%run requirements02

该脚本与第一章中描述的 OpenAI 脚本相同，但已针对 Pinecone 进行了适配。我们首先卸载 Pinecone，然后安装所需的版本：

The script is the same as the one for OpenAI described in Chapter 1, but adapted to Pinecone. We first uninstall Pinecone and then install the version we need:

import subprocess
import sys
def run_command(command):
    try:
        subprocess.check_call(command)
    except subprocess.CalledProcessError as e:
        print(f"Command failed: {' '.join(command)}\nError: {e}")
        sys.exit(1)
# Uninstall the 'pinecone-client' package
print("Uninstalling 'pinecone-client'...")
run_command(
    [sys.executable, "-m", "pip", "uninstall", "-y", "pinecone-client"]
)
# Install the specific version of 'pinecone-client'
print("Installing 'pinecone-client' version 5.0.1...")
run_command(
    [
        sys.executable, "-m", "pip", "install",\
        "--force-reinstall", "pinecone-client==5.0.1"
    ]
)

然后，我们验证安装情况：

Then, we verify the installation:

# Verify the installation
try:
    import pinecone
    print(
        f"'pinecone-client' version {pinecone.__version__} is installed."
)
except ImportError:
    print(
        "Failed to import the 'pinecone-client' library after installation."
)
    sys.exit(1)

输出结果显示客户端已成功安装：

The output shows we have successfully installed the client:

Uninstalling 'pinecone-client'...
Installing 'pinecone-client' version 5.0.1...
'pinecone-client' version 5.0.1 is installed.

接下来，我们来初始化 Pinecone API 密钥。

Let’s go ahead and initialize the Pinecone API key.

初始化 Pinecone API 密钥

Initializing the Pinecone API key

这程序现在开始下载pinecone_setup.py，我们将使用它来初始化 Pinecone API 密钥：

The program now downloads pinecone_setup.py, which we will use to initialize the Pinecone API key:

download("commons","pinecone_setup.py")

这种设置与我们在第 1 章中用于 OpenAI 的基于 Google Colab 密钥的方法类似，但在这里进行了调整，用于初始化 Pinecone API。

This setup mirrors the Google Colab secrets-based approach we used for OpenAI in Chapter 1, but it’s adapted here for initializing the Pinecone API.:

# Import libraries
import openai
import os
from google.colab import userdata
# Function to initialize the Pinecone API key
def initialize_pinecone_api():
    # Access the secret by its name
    PINECONE_API_KEY = userdata.get('PINECONE_API_KEY')
  
    if not PINECONE_API_KEY:
        raise ValueError("PINECONE_API_KEY is not set in userdata!")
  
    # Set the API key in the environment and OpenAI
    os.environ['PINECONE_API_KEY'] = PINECONE_API_KEY
    print("PINECONE_API_KEY initialized successfully.")

如果如果在本笔记本的 OpenAI 部分中将 Google Secrets 设置True为 OpenAI，则会调用 Pinecone 设置函数：

If Google secrets was set to True for OpenAI in the OpenAI section of this notebook, then the Pinecone setup function will be called:

if google_secrets==True:
    import pinecone_setup
    pinecone_setup.initialize_pinecone_api()

如果 Google Secrets 设置为 true False，则可以通过取消注释代码并使用您希望的任何方法输入 Pinecone API 密钥来实现自定义函数：

If Google secrets was set to False, then you can implement a custom function by uncommenting the code and entering the Pinecone API key with any method you wish:

if google_secrets==False: # Uncomment the code and choose any method you wish to initialize the Pinecone API key
    import os
    #PINECONE_API_KEY=[YOUR PINECONE_API_KEY]
    #os.environ['PINECONE_API_KEY'] = PINECONE_API_KEY
    #openai.api_key = os.getenv("PINECONE_API_KEY")
    #print("Pinecone API key initialized successfully.")

程序现在已准备好处理我们将要插入到 Pinecone 索引中的数据。

The program is now ready to process the data we will upsert to the Pinecone index.

处理数据

Processing data

我们的目标现在需要准备存储和检索场景，以便我们能够查询 Pinecone 索引。该过程的主要步骤如图 3.2所示，这只是后续章节路线图中的一层。我们将按以下步骤处理数据：

Our goal now is to prepare the scenarios for storage and retrieval so that we can then query the Pinecone index. The main steps of the process are represented in Figure 3.2, which is only one layer of the roadmap for the following chapters. We will process the data in the following steps:

1. 数据加载和准备阶段，数据将被拆分成更小的部分。在本例中，每个场景将存储在场景列表的一行中，这将为分块过程做好准备。但是，我们并非总是将文本拆分成行，这一点我们将在后面的“将经典数据更新插入索引”部分中看到。
1. Data loading and preparation, in which the data will be broken into smaller parts. In this case, each scenario will be stored in one line of a scenario list, which will prepare the chunking process. We will not always break text into lines, however, as we will see in the Upserting classical data into the index section later.
2. 分块功能，可将每行场景存储成块。
3. Chunking functionality to store each line of scenarios into chunks.
4. 将获取的文本块嵌入到文本中。
5. Embedding the chunks of text obtained.
6. 验证以确保我们嵌入了相应数量的数据块。
7. Verification to ensure that we embedded the corresponding number of chunks.

现在我们来介绍前两个步骤：加载和准备数据，然后进行分块。

Let’s now cover the first two steps: loading and preparing the data, followed by chunking.

数据加载和分块

Data loading and chunking

我们将使用第二章中实现的各种场景都存储在一个文件中，我们现在就来下载这个文件：

We will use the scenarios implemented in Chapter 2. They are stored in a file that we will now download:

download("Chapter03","scenario.csv")

在本书中，我们将逐步添加更多场景，最终构建一个 GenAISys。目前，我们的主要目标是让 Pinecone 索引正常工作。程序首先初始化start_time以进行时间测量。然后，我们将场景指令逐行加载到chunks程序中：

We will add more scenarios throughout our journey in this book to create a GenAISys. For the moment, our main objective is to get our Pinecone index to work. The program first initializes start_time for time measurement. Then we load the lines of scenario instructions directly into chunks line by line:

import time
start_time = time.time()  # Start timing
# File path
file_path = 'scenario.csv'
# Read the file, skip the header, and clean the lines
chunks = []
with open(file_path, 'r') as file:
    next(file)  # Skip the header line
    chunks = [line.strip() for line in file]  # Read and clean lines as chunks

然后代码会显示数据块的数量以及创建这些数据块所花费的时间：

Then the code displays the number of chunks and the time it took to create the chunks:

response_time = time.time() - start_time  # Measure response time
print(f"Response Time: {response_time:.2f} seconds")  # Print response time

Total number of chunks: 3
Response Time: 0.00 seconds

该程序现在验证场景指令的前三部分：

The program now verifies the first three chunks of scenario instructions:

# Optionally, print the first three chunks for verification
for i, chunk in enumerate(chunks[:3], start=1):
    print(chunk)

输出结果显示了本章我们将要讨论的三种场景：

The output shows the three scenarios we will be working on in this chapter:

['ID,SCENARIO\n',
 '100,Semantic analysis.This is not an analysis but a semantic search. Provide more information on the topic.\n',
 '200,Sentiment analysis  Read the content return a sentiment analysis nalysis on this text and provide a score with the label named : Sentiment analysis score followed by a numerical value between 0 and 1  with no + or - sign and  add an explanation to justify the score.\n',
 '300,Semantic analysis.This is not an analysis but a semantic search. Provide more information on the topic.\n']

数据块已准备好进行嵌入。让我们开始嵌入过程。

The chunks of data are now ready for embedding. Let’s proceed with embedding.

嵌入数据集

Embedding the dataset

嵌入对于数据集，我们首先初始化嵌入模型，然后对数据块进行嵌入。程序首先初始化嵌入模型。

To embed the dataset, we will first initialize the embedding model and then embed the chunks. The program first initializes the embedding model.

初始化嵌入模型

Initializing the embedding model

我们我们将使用 OpenAI 嵌入模型来嵌入数据。要使用 OpenAI 模型嵌入数据，我们可以选择以下三种主要模型之一：

We will be using an OpenAI embedding model to embed the data. To embed our data with an OpenAI model, we can choose one of three main models:

• text-embedding-3-small它速度快，资源占用低，足以满足实时应用的需求。它体积较小，因此成本效益高。然而，随着场景复杂度的增加，向量存储的大小也会增加，因此对于精细化的任务，其精度可能会降低。
• text-embedding-3-small, which is fast and has a lower resource usage. This is sufficient for real-time usage. It is a smaller model and is thus cost-effective. However, as the vector store will increase in size with complex scenarios, it might be less accurate for nuanced tasks.
• text-embedding-3-large该方法能够提供高精度和细致入微的词嵌入，对于复杂的语义相似性搜索非常有效。但它需要更多资源，成本也更高。
• text-embedding-3-large, which provides high accuracy and nuanced embeddings and will prove effective for complex semantic similarity searches. It requires more resources and costs more.
• text-embedding-ada-002对于高质量的嵌入来说，它是一种经济高效的选择。但是，它的速度比诸如text-embedding-3-small和之类的模型稍慢text-embedding-3-large。
• text-embedding-ada-002, which is cost-effective for good-quality embeddings. However, it’s slightly slower than models such as text-embedding-3-small and text-embedding-3-large.

为了在本章中导入有限数量的场景，我们将使用text-embedding-3-small优化速度和成本的方法。程序会初始化模型，而其他部分则以注释的形式提供，以便日后需要时使用：

To import a limited number of scenarios in this chapter, we will use text-embedding-3-small to optimize speed and cost. The program initializes the model while the others are commented for further use if needed:

import openai
import time
embedding_model="text-embedding-3-small"
#embedding_model="text-embedding-3-large"
#embedding_model="text-embedding-ada-002"

我们初始化 OpenAI 客户端：

We initialize the OpenAI client:

# Initialize the OpenAI client
client = openai.OpenAI()

然后创建一个嵌入函数，将发送给它的文本转换为嵌入向量。该函数旨在为一批输入文本（texts）生成嵌入，使用的嵌入模型是我们选择的，在本例中为text-embedding-3-small：

An embedding function is then created that will convert the text sent to it into embeddings. The function is designed to produce embeddings for a batch of input texts (texts) with the embeddings model of our choice, in this case, text-embedding-3-small:

def get_embedding(texts, model="text-embedding-3-small")

该函数首先清理文本，将每段文本中的换行符替换为空格：

The function first cleans the text by replacing newline characters in each text with spaces:

texts = [text.replace("\n", " ") for text in texts]

然后，该函数会发起 API 嵌入调用：

Then, the function makes the API embedding call:

response = client.embeddings.create(input=texts, model=model)

词嵌入是从响应中提取出来的：

The embeddings are extracted from the response:

embeddings = [res.embedding for res in response.data]  # Extract embeddings

最后，返回嵌入向量：

Finally, the embeddings are returned:

return embeddings

程序现在可以嵌入数据块了。

The program is now ready to embed the chunks.

嵌入数据块

Embedding the chunks

该程序首先定义一个用于嵌入数据块的函数：

The program first defines a function to embed the chunks:

def embed_chunks(
    chunks, embedding_model="text-embedding-3-small",
    batch_size=1000, pause_time=3
):

该函数的参数如下：

The parameters of the function are:

• chunks要嵌入的文本部分
• chunks: The parts of text to embed
• embedding_model：定义要使用的模型，例如：text-embedding-3-small
• embedding_model: Defines the model to use, such as text-embedding-3-small
• batch_size函数在单个批次中可以处理的块数，例如batch_size=1000
• batch_size: The number of chunks the function can process in a single batch, such as batch_size=1000
• pause_time暂停时间（以秒为单位），可用于速率限制。
• pause_time: A pause time in seconds, which can be useful for rate limits

然后我们初始化计时函数、embeddings变量和计数器：

We then initialize the timing function, embeddings variable, and counter:

start_time = time.time()  # Start timing the operation
embeddings = []  # Initialize an empty list to store the embeddings
counter = 1  # Batch counter

代码是现在可以分批处理数据块了：

The code is now ready to process the chunks in batches:

# Process chunks in batches
    for i in range(0, len(chunks), batch_size):
        chunk_batch = chunks[i:i + batch_size]  # Select a batch of chunks

然后，将每个批次发送到嵌入函数：

Each batch is then sent to the embedding function:

        # Get the embeddings for the current batch
        current_embeddings = get_embedding(
            chunk_batch, model=embedding_model
        )

嵌入的批次被添加到嵌入列表中：

The embedded batch is appended to the embeddings list:

# Append the embeddings to the final list
        embeddings.extend(current_embeddings)

监控并显示批次数量，并激活暂停功能：

The number of batches is monitored and displayed and the pause is activated:

   # Print batch progress and pause
        print(f"Batch {counter} embedded.")
        counter += 1
        time.sleep(pause_time)  # Optional: adjust or remove this depending on rate limits

所有批次处理完毕后，将显示总耗时：

Once all the batches are processed, the total time is displayed:

   # Print total response time
    response_time = time.time() - start_time
    print(f"Total Response Time: {response_time:.2f} seconds")

嵌入函数已准备就绪，可以使用数据块列表调用它：

The embedding function is ready to be called with the chunks list:

embeddings = embed_chunks(chunks)

输出结果显示场景数据已嵌入：

The output shows that the scenario data has been embedded:

Batch 1 embedded.
Total Response Time: 4.09 seconds

显示第一个嵌入以供验证：

The first embedding is displayed for verification:

print("First embedding:", embeddings[0])

输出确认嵌入已生成：

The output confirms that the embeddings have been generated:

First embedding: [0.017762450501322746, 0.041617266833782196, -0.024105189368128777,…

最后一步验证是检查嵌入的数量是否与数据块的数量相匹配：

The final verification is to check that the number of embeddings matches the number of chunks:

# Check the lengths of the chunks and embeddings
num_chunks = len(chunks)
print(f"Number of chunks: {num_chunks}")
print(f"Number of embeddings: {len(embeddings)}")

输出结果证实，分块和嵌入过程很可能已经成功：

The output confirms that the chunking and embedding process is most probably successful:

Number of chunks: 3
Number of embeddings: 3

现在数据块和嵌入已准备好插入到 Pinecone 索引中。

The chunks and embeddings are now ready to be upserted into the Pinecone index.

创建松果指数

Creating the Pinecone index

松果genai-v1指数我们将创建包含两个命名空间的目录，如图 3.3所示：

The genai-v1 Pinecone index we will create will contain two namespaces, as shown in Figure 3.3:

• genaisys：一个指令场景库。这些提示可以驱动生成式人工智能行为，也可以触发传统功能，例如网络搜索。
• genaisys: A repository of instruction scenarios. These prompts drive generative AI behavior and can also trigger traditional functions such as web search.
• Data01：RAG 管道查询的嵌入式经典数据。
• Data01: The embedded classical data that the RAG pipeline queries.

图 3.3：将 Pinecone 索引划分为命名空间

Figure 3.3: Partitioning the Pinecone index into namespaces

我们首先导入两个类：

We begin by importing two classes:

from pinecone import Pinecone, ServerlessSpec

班级Pinecone​这是与 Pinecone 索引交互的主要接口。我们将使用此类来配置 Pinecone 的无服务器服务。

The Pinecone class is the primary interface to interact with the Pinecone index. We will use this class to configure Pinecone’s serverless services.

在继续之前，您需要注册一个 Pinecone 账户并获取 API 密钥。请务必访问https://www.pinecone.io/查看这些服务的费用。本章内容完整，您可以先阅读正文、注释和代码，然后再决定是否创建 Pinecone 账户。

Before going further, you will need to set up a Pinecone account and obtain an API key. Make sure to verify the cost of these services at https://www.pinecone.io/. This chapter is self-contained, so you can begin by reading the content, comments, and code before deciding on creating a Pinecone account.

账户设置完成后，我们需要获取并初始化我们的 API 密钥：

Once our account is set up, we need to retrieve and initialize our API key:

# Retrieve the API key from environment variables
api_key = os.environ.get('PINECONE_API_KEY')
if not api_key:
    raise ValueError("PINECONE_API_KEY is not set in the environment!")
# Initialize the Pinecone client
pc = Pinecone(api_key=api_key)

现在我们导入规范类，定义索引名称（ ），并为我们的场景genai-v1初始化第一个命名空间（ ）：genaisys

We now import the specification class, define the name of our index (genai-v1), and initialize our first namespace (genaisys) for our scenarios:

from pinecone import ServerlessSpec
index_name = "genai-v1"
namespace="genaisys"

我们现在需要做出一个项目管理决策——使用 Pinecone 云托管我们的索引，还是使用亚马逊网络服务( AWS )？

We now have a project management decision to make—use the Pinecone cloud to host our index or Amazon Web Services (AWS)?

cloud = os.environ.get('PINECONE_CLOUD') or 'aws'
region = os.environ.get('PINECONE_REGION') or 'us-east-1'
spec = ServerlessSpec(cloud=cloud, region=region)

代码首先检查是否PINECONE_CLOUD已设置环境变量（）以使用 Pinecone 云。如果没有预定义的环境变量检查，则该变量默认使用 AWS，'aws'并将'us-east-1'设置为默认区域。

The code first checks whether an environment variable (PINECONE_CLOUD) is set to use the Pinecone cloud. If there is no predefined environment variable check set, the variable defaults to AWS with 'aws' and 'us-east-1' as the default region.

在这种情况下，选择 AWS 的原因如下：

In this case, AWS was chosen for the following reasons:

• 市场领导地位和可靠性：AWS在全球基础设施市场占有超过30%的市场份额。因此，它被众多组织视为可靠的服务提供商。
• Market leadership and reliability: AWS has a market share of over 30% of the global infrastructure market. As such, it is deemed reliable by a large number of organizations.
• 合规性和安全标准：AWS 拥有超过 140 项数据安全和隐私安全标准，包括 PCI-DSS 和 HIPAA/HITECH、FedRAMP、GDPR、FIPS 140-2 和 NIST 800-171。
• Compliance and security standards: AWS has over 140 security standards for data security and privacy, including PCI-DSS and HIPAA/HITECH, FedRAMP, GDPR, FIPS 140-2, and NIST 800-171.
• 可扩展性：AWS 拥有全球数据中心网络，可实现无缝扩展。
• Scalability: AWS has a global network of data centers, making scalability seamless.

或者，你您可以在 Pinecone 控制台中手动创建索引，以选择嵌入模型和主机，例如 AWS 或Google Cloud Platform ( GCP )。您还可以选择 pod 大小，从 x1 到更大值，这将决定索引的最大大小。每个选择都取决于您的项目和资源优化策略。

Alternatively, you can create an index manually in your Pinecone console to select the embedding model and the host, such as AWS or Google Cloud Platform (GCP). You can also select your pod size from x1 to more, which will determine the maximum size of your index. Each choice depends on your project and resource optimization strategy.

总之，我们需要一些指标来监控使用情况和成本。Pinecone 提供详细的使用情况指标，您可以通过帐户访问这些指标，从而高效地管理索引。例如，我们可能需要删除您不再需要的信息、添加目标数据或优化每个用户的使用情况。

In any case, we need metrics to monitor usage and cost. Pinecone provides detailed usage metrics accessible via your account, allowing you to manage indexes efficiently. For example, we might want to delete information you don’t need anymore, add targeted data, or optimize the usage per user.

Pinecone 提供三个关键指标：

Pinecone provides three key metrics:

• 无服务器存储使用量：以千兆字节小时( GB 小时) 为单位计量。成本按每小时 1 GB 存储空间计算。在任何人工智能项目中，密切监控数据存储量都是至关重要的因素。
• Serverless storage usage: Measured in gigabyte-hours (GB-hours). The cost is calculated at 1 GB of storage per hour. Carefully monitoring the amount of data we store is an important factor in any AI project.
• 无服务器写入操作单位：衡量对包含我们索引的 Pinecone 数据库进行写入操作所消耗的资源。
• Serverless write operations units: Measures the resources consumed by write operations to the Pinecone database that contains our index.
• 无服务器读取操作 单元：衡量读取操作消耗的资源。
• Serverless read operations units: Measures the resources consumed by read operations.

您可以登录 Pinecone 账户，选择“使用情况”，然后点击“下载”按钮，即可下载详细的消费信息，如下图所示：

You can download detailed information on your consumption by going to your Pinecone account, selecting Usage, and then clicking on the Download button, as shown here:

图 3.4：下载松果使用数据

Figure 3.4: Downloading Pinecone usage data

下载的文件为 CSV 格式，其中包含我们 Pinecone 使用情况的详细记录，例如BillingAccountId （帐户标识符）、BillingAccountName （帐户名称）、OrganizationName（组织名称）、 OrganizationId（组织 ID）、ProjectId （项目标识符）、ProjectName （项目名称）、 ResourceId（资源标识符）、ResourceName （资源名称）、ChargePeriodStart （收费开始日期）、ChargePeriodEnd（收费结束日期）、 BillingPeriodStart （账单开始日期）、BillingPeriodEnd （账单结束日期）、SkuId（SKU 标识符）、SkuPriceId（SKU 价格 ID）、ServiceName（服务名称）、ChargeDescription （收费详情）、CloudId （云提供商）、RegionId （区域）、Currency（货币类型）、PricingQuantity（使用量）、PricingUnit（使用单位） 、（ListCost列出成本）、EffectiveCost（计算成本）、BilledCost（最终成本）和Metadata（附加数据）。

The download file is in CSV format and contains a detailed account of our Pinecone usage, such as BillingAccountId (account identifier), BillingAccountName (account name), OrganizationName (organization name), OrganizationId (organization ID), ProjectId (project identifier), ProjectName (project name), ResourceId (resource identifier), ResourceName (resource name), ChargePeriodStart (charge start date), ChargePeriodEnd (charge end date), BillingPeriodStart (billing start date), BillingPeriodEnd (billing end date), SkuId (SKU identifier), SkuPriceId (SKU price ID), ServiceName (service name), ChargeDescription (charge details), CloudId (cloud provider), RegionId (region), Currency (currency type), PricingQuantity (usage quantity), PricingUnit (usage unit), ListCost (listed cost), EffectiveCost (calculated cost), BilledCost (final cost), and Metadata (additional data).

我们现在将检查我们选择的索引是否存在。程序导入了 ` pineconeand`time类，以便在检查索引是否存在之前插入一个睡眠时间：

We will now check whether the index we selected exists or not. The program imports the pinecone and time classes to insert a sleep time before checking whether the index exists:

import time
import pinecone
# check if index already exists (it shouldn't if this is first time)
if index_name not in pc.list_indexes().names():

如果索引已存在，则跳过以下代码以避免创建重复索引。否则，将创建一个索引：

If the index exists, the following code will be skipped to avoid creating duplicate indexes. If not, an index is created:

   # if does not exist, create index
    pc.create_index(
        index_name,
        dimension=1536,  # dimension of the embedding model
        metric='cosine',
        spec=spec
    )
    # wait for index to be initialized
    time.sleep(1)

参数如下：

The parameters are as follows:

• index_name这就是我们松果指数的名称，genai-v1
• index_name, which is the name of our Pinecone index, genai-v1
• dimension=1536嵌入向量的维度
• dimension=1536, the dimensionality of the embedding vectors
• metric='cosine'它将相似性搜索的距离度量设置为余弦相似度。
• metric='cosine', which sets the distance metric for similarity searches to cosine similarity
• spec=spec它定义了区域以及我们之前为云服务定义的无服务器规范
• spec=spec, which defines the region and the serverless specification we defined previously for the cloud services
• time.sleep(1)这样一来，程序就会等待，以确保索引完全创建后再继续执行。
• time.sleep(1), which makes the program wait to make sure the index is fully created before continuing

如果索引刚刚创建，输出将显示其详细信息，并将total_vector_count设置为0（如果您看到除 0 以外的数字0，则笔记本可能已经运行过）：

If the index has just been created, the output shows its details with total_vector_count set to 0 (if you see a number other than 0, the notebook has likely already been run):

{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {},
 'total_vector_count': 0}

如果索引如果已存在，则会显示统计信息，包括index_fullness监控索引 pod 中使用的空间（从 0 到 1）：

If the index already exists, the statistics will be displayed, including index_fullness to monitor the space used in your index pod from 0 to 1:

Index stats
{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'genaisys': {'vector_count': 3}},
 'total_vector_count': 3}

在这种情况下，我们还没有填充索引。我们可以连接到刚刚创建的索引，并在填充之前显示其统计信息：

In this case, we haven’t populated the index yet. We can connect to the index we just created and display its statistics before populating it:

# connect to index
index = pc.Index(index_name)
# view index stats
index.describe_index_stats()

输出结果显示相关信息，确认连接已建立：

The output displays the information, confirming that we are connected:

{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'genaisys': {'vector_count': 0}},
 'total_vector_count': 0}

所选嵌入模型必须与 Pinecone 索引的维度相匹配（ ）。我们将在第 5 章1536开始处理用例时，以交互方式创建 Pinecone 索引的参数。这里，我们使用具有 1536 个维度的模型，这与 Pinecone 索引的维度相匹配。embedding_model="text-embedding-3-small

The selected embedding model must match Pinecone’s index dimension (1536). We will create the parameters of a Pinecone index interactively when we begin working on use cases in Chapter 5. Here, we are using embedding_model="text-embedding-3-small with its 1,536 dimensions, which matches the dimension of the Pinecone index.

另请注意，'genaisys'我们初始化的命名空间也会被考虑在内。这确保了当我们按照我们设计的场景进行更新插入操作后，它们不会与同一索引中另一个命名空间中的经典数据混淆。现在，我们已准备好将数据更新插入到我们的 Pinecone 索引中。

Note also that the 'genaisys' namespace we initialized is taken into account. This ensures that when we upsert the scenarios we designed, they will not be confused with the classical data that is in another namespace of the same index. We are now ready to upsert the data to our Pinecone index.

将指令场景更新插入索引

Upserting instruction scenarios into the index

插入嵌入式如本节开头所述，对 Pinecone 索引进行数据块更新会带来一定的成本。我们必须谨慎决定要更新哪些数据。如果我们更新所有数据，则可能会出现以下情况：

Upserting embedded chunks into a Pinecone index comes with a cost, as explained at the beginning of this section. We must carefully decide which data to upsert. If we upsert all the data, we might do the following:

• 使索引过载，增加检索难度，无论是指令场景还是经典数据。
• Overload the index and make retrieval challenging, be it instruction scenarios or classical data
• 提高读写操作的成本
• Drive up the cost of write and read operations
• 添加过多的噪声，导致无法控制，并扰乱检索功能。
• Add more noise than is manageable and confuse the retrieval functions

如果我们选择不进行数据插入操作，我们有两种选择：

If we choose not to upsert the data, we have two options:

• 内存实时查询：将分块的嵌入式数据加载到内存中并实时查询信息，可以减轻数据存储的压力，并且是一种处理无需存储的临时信息（例如每日天气预报）的实用方法。然而，对于我们将在第五章开始讨论的用例，我们也必须权衡这种方法与每一步都使用 upsert 操作的成本/收益。
• Querying in real time in memory: Loading chunked, embedded data into memory and querying the information in real time could alleviate the data store and be a pragmatic way to deal with ephemeral information we don’t need to store, such as the daily weather forecast. However, we must also weigh the cost/benefit of this approach versus upserting at each step for the use cases we’ll be working on starting from Chapter 5.
• 数据微调：这需要构建训练数据集，而构建数据集需要人力和计算资源。对于快速变化的市场，我们可能需要定期进行微调，这需要大量的投入。成本效益将由项目管理团队进行权衡。第五章将探讨微调与 RAG 的成本效益分析。
• Fine-tuning data: This comes with the cost of building training datasets, which requires human and computing resources. In the case of fast-moving markets, we might have to fine-tune regularly, which entails high investments. The cost/benefit will be up to the project management team to consider. A cost-benefit analysis of fine-tuning versus RAG will be explored in Chapter 5.

我们首先初始化库并启动计时器来测量脚本运行所需的时间：

We first initialize the libraries and start a timer to measure how long it takes to run the script:

import pinecone
import time
import sys
start_time = time.time()  # Start timing before the request

程序随后必须计算发送给 Pinecone 的最大批次大小。为了安全起见，该值设置为 400,000 字节，即 4 MB。如果达到限制，则返回批次大小：

The program must then calculate the maximum size of the batch we send to Pinecone. It is set to 400,000 bytes, or 4 MB, to play it safe. If the limit is reached, the batch size is returned:

# Function to calculate the size of a batch
def get_batch_size(data, limit=4000000):  # limit set to 4MB to be safe
    total_size = 0
    batch_size = 0
    for item in data:
        item_size = sum([sys.getsizeof(v) for v in item.values()])
        if total_size + item_size > limit:
            break
        total_size += item_size
        batch_size += 1
    return batch_size

我们现在需要一个upsert在调用时能考虑批处理大小的函数：

We now need an upsert function that takes the batch size into account when called:

# Upsert function with namespace
def upsert_to_pinecone(batch, batch_size, namespace="genaisys"):
    """
    Upserts a batch of data to Pinecone under a specified namespace.
    """
    try:
        index.upsert(vectors=batch, namespace=namespace)
        print(
            f"Upserted {batch_size} vectors to namespace '{namespace}'."
        )
    except Exception as e:
        print(f"Error during upsert: {e}")

请注意，我们将把指令场景更新插入到genaisysPinecone 索引下的命名空间中。现在我们可以定义主要的批量更新插入函数：

Note that we will upsert the instruction scenarios into the namespace, genaisys, within the Pinecone index. We can now define the main batch upsert function:

def batch_upsert(data):

该函数首先确定数据的总长度，然后准备与它将要计算的批次大小相匹配的批次get_batch_size。接着，它创建一个批次并将其发送到upsert_to_pinecone我们定义的函数：

The function begins by determining the total length of the data and then prepares batches that match the batch size that it will calculate with the get_batch_size function. Then, it creates a batch and sends it to the upsert_to_pinecone function we defined:

# Function to upsert data in batches
def batch_upsert(data):
    total = len(data)
    i = 0
    while i < total:
        batch_size = get_batch_size(data[i:])
        batch = data[i:i + batch_size]
        if batch:
            upsert_to_pinecone(batch, batch_size, namespace="genaisys")
            i += batch_size
            print(f"Upserted {i}/{total} items...")  # Display current progress
        else:
            break
    print("Upsert complete.")

当upsert 操作完成后，输出将显示成功消息，表明我们已准备好进行 upsert 操作。Pinecone 索引需要一个 ID，我们现在将创建该 ID：

When the upsert is completed, the output will display a success message, signaling that we are ready to prepare the upsert process. A Pinecone index requires an ID that we will now create:

# Generate IDs for each data item
ids = [str(i) for i in range(1, len(chunks) + 1)]

每个嵌入的数据块都有了 ID 之后，我们需要将数据格式化以适应 Pinecone 的索引结构：

Once each embedded chunk has an ID, we need to format the data to fit Pinecone’s index structure:

# Prepare data for upsert
data_for_upsert = [
    {"id": str(id), "values": emb, "metadata": {"text": chunk}}
    for id, (chunk, emb) in zip(ids, zip(chunks, embeddings))
]

现在数据已格式化，包含 ID、值（嵌入）和元数据（数据块）。接下来，我们调用batch_upsert将调用我们创建的相关函数的函数：

The data is now formatted with an ID, values (embeddings), and metadata (the chunks). Let’s call the batch_upsert function that will call the related functions we created:

# Upsert data in batches
batch_upsert(data_for_upsert)

upsert 操作完成后，将显示已插入到命名空间的向量数量以及所用时间：

When the upserting process is finished, the number of vectors upserted to the namespace and the time it took are displayed:

Upserted 3 vectors to namespace 'genaisys'.
Upserted 3/3 items...
Upsert complete.
Upsertion response time: 0.45 seconds

我们还可以展示松果指数的统计数据：

We can also display the statistics of the Pinecone index:

#You might have to run this cell after a few seconds to give Pinecone
#the time to update the index information
print("Index stats")
print(index.describe_index_stats(include_metadata=True))

输出结果显示以下信息：

The output displays the information:

Index stats
{'dimension': 1536,
 'index_fullness': 0.0,
 'namespaces': {'genaisys': {'vector_count': 3}},
 'total_vector_count': 3}

显示的信息如下：

The information displayed is as follows:

• 'dimension': 1536嵌入的维度。
• 'dimension': 1536: Dimension of the embeddings.
• 'index_fullness': 0.0：一个介于 0 和 1 之间的值，表示 Pinecone 索引的填充程度。我们必须监控此值，以优化我们正在更新插入的数据，避免出现问题。我们需要增加所使用的存储容量。更多信息，请参阅 Pinecone 文档：https://docs.pinecone.io/guides/get-started/overview。
• 'index_fullness': 0.0: A value between 0 and 1 that shows how full the Pinecone index is. We must monitor this value to optimize the data we are upserting to avoid having to increase the size of the storage capacity we are using. For more information, consult the Pinecone documentation at https://docs.pinecone.io/guides/get-started/overview.
• 'namespaces': {'genaisys': {'vector_count': 3}}显示命名空间和向量计数。
• 'namespaces': {'genaisys': {'vector_count': 3}}: Displays the namespace and vector count.
• 'total_vector_count': 3}：显示松果索引中的向量总数。
• 'total_vector_count': 3}: Displays the total vector count in the Pinecone index.

现在我们准备将经典数据上传到其命名空间。

We are now ready to upload the classical data into its namespace.

将经典数据更新插入索引

Upserting classical data into the index

建筑GenAISys 涉及多个团队。为了让每个团队能够并行工作以优化生产时间，我们将把经典数据插入到单独的程序/笔记本中。一个团队可以负责编写指令场景，而另一个团队则可以负责收集和处理数据。

Building a GenAISys involves teams. So that each team can work in parallel to optimize production times, we will upsert the classical data in a separate program/notebook. One team can work on instruction scenarios while another team works on gathering and processing data.

打开笔记本Pinecone_RAG.ipynb。我们将重用本章“构建动态 Pinecone 索引”Pinecone_instruction_scenarios.ipynb部分中构建的笔记本的几个组件。环境设置与之前的笔记本相同。Pinecone 索引也相同。源数据 upsert 的命名空间是 `<namespace>` ，正如我们在前面的章节中已经确定的那样，以确保数据与指令场景分离。因此，唯一的真正区别在于我们加载的数据和分块方法。让我们开始吧！genai-v1data01

Open Pinecone_RAG.ipynb. We will be reusing several components of the Pinecone_instruction_scenarios.ipynb notebook built in the Building a dynamic Pinecone index section of this chapter. Setting up the environment is identical to the previous notebook. The Pinecone index is the same, genai-v1. The namespace for source-data upserting is data01, as we’ve already established in earlier sections, to make sure the data is separated from the instruction scenarios. So, the only real difference is the data we load and the chunking method. Let’s get into it!

数据加载和分块

Data loading and chunking

这该部分使用与指令场景相同的流程嵌入数据块Pinecone_instruction_scenarios.ipynb。然而，这一次，GPT-4o 并没有这样做。分块处理。在导入指令场景时，我们希望保持场景的完整性，以便能够为生成式人工智能模型提供完整的指令集。在这种情况下，我们将利用生成式人工智能的强大功能，使用 GPT-4o 对原始文本进行分块处理。

This section embeds chunks using the same process as for instruction scenarios in Pinecone_instruction_scenarios.ipynb. However, this time, GPT-4o does the chunking. When importing lines of instruction scenarios, we wanted to keep the integrity of the scenario in one chunk to be able to provide a complete set of instructions to the generative AI model. In this case, we will leverage the power of generative AI and chunk raw text with GPT-4o.

我们首先下载数据（而不是场景），并设置文件路径：

We begin by downloading data, not scenarios, and setting the path of the file:

download("Chapter03","data01.txt")
# Load the CSV file
file_path = '/content/data01.txt'

现在，文本文件作为一个大块被加载到一个变量中并显示出来：

Now, the text file is loaded as one big chunk in a variable and displayed:

try:
    with open(file_path, 'r') as file:
        text = file.read()
    text
except FileNotFoundError:
    text = "Error: File not found. Please check the file path."
print(text)

您可以添加注释print(text)或仅打印几行内容。在本例中，我们来验证是否已正确导入文件。输出结果显示已成功导入：

You can comment print(text) or only print a few lines. In this case, let’s verify that we have correctly imported the file. The output shows that we did:

The CTO was explaing that a business-ready generative AI system (GenAISys) offers functionality similar to ChatGPT-like platforms…

这文本包含来自我们正在上传数据到我们自定义 RAG 数据库的公司的首席技术官 (CTO) 的消息。可能存在数千条此类内部消息——数量太多（而且变化太快），不足以支撑模型微调。Pinecone 只存储关键信息块，既能提供可搜索的上下文，又不会让索引充斥噪声。

The text contains a message from the CTO of the company whose data we are uploading to our custom RAG database. A company might have thousands of such internal messages—far too many (and too volatile) to justify model fine-tuning. Storing only the key chunks in Pinecone gives us searchable context without flooding the index with noise.

该text变量尚未准备好被 GPT-4o 进行分块处理。第一步是创建一个 OpenAI 实例，并向 GPT-4o 模型提供指令：

The text variable is not ready yet to be chunked by GPT-4o. The first step is to create an OpenAI instance and give the GPT-4o model instructions:

# Import libraries
from openai import OpenAI
# Initialize OpenAI Client
client = OpenAI()
# Function to chunk text using GPT-4o
def chunk_text_with_gpt4o(text):
    # Prepare the messages for GPT-4o
    messages = [
        {"role": "system", "content": "You are an assistant skilled at splitting long texts into meaningful, semantically coherent chunks of 50-100 words each."},
        {"role": "user", "content": f"Split the following text into meaningful chunks:\n\n{text}"}
    ]
Now we send the request to the API:
    # Make the GPT-4o API call
    response = client.chat.completions.create(
        model="gpt-4o",  # GPT-4o model
        messages=messages,
        temperature=0.2,  # Low randomness for consistent chunks
        max_tokens=1024  # Sufficient tokens for the chunked response
    )

我们需要密切关注max_tokens=1024设置：GPT-4o 一旦达到限制就会停止生成。对于非常大的文档，您可以将文本分成较小的片段进行流式传输，然后让 GPT-4o 对每个片段进行优化。我们还可以使用现成的分块函数，将文本分解成优化后的块，以便在检索数据时获得更细致、更精确的结果。但是，在这种情况下，让我们最大限度地利用 GPT-4o；我们将整个文件一次性发送。用低温进行呼叫，以便我们观察模型将真实文档从头到尾分割成多个部分。

We need to keep an eye on the max_tokens=1024 setting: GPT-4o will stop generating once it hits that limit. For very large documents, you can stream the text in smaller slices—then let GPT-4o refine each slice. We can also use ready-made chunking functions that will break the text down into optimized chunks to obtain more nuanced and precise results when retrieving the data. However, in this case, let’s maximize the usage of GPT-4o; we send the entire file in one call with a low temperature so we can watch the model partition a real-world document from end to end.

现在我们可以从响应中检索数据块，对其进行清理，将它们存储在数据块列表中，然后返回该chunks变量：

Now we can retrieve the chunks from the response, clean them, store them in a list of chunks, and return the chunks variable:

   # Extract and clean the response
    chunked_text = response.choices[0].message.content
    chunks = chunked_text.split("\n\n")  # Assume GPT-4o separates chunks with double newlines
    return chunks

现在，我们可以调用分块函数了。我们不必显示代码块，并且可以在生产环境中对代码进行注释。不过，在这种情况下，让我们先验证一下一切是否正常：

Now, we can call the chunking function. We don’t have to display the chunks and can comment the code in production. However, in this case, let’s verify that everything is working:

# Chunk the text
chunks = chunk_text_with_gpt4o(text)
# Display the chunks
print("Chunks:")
for i, chunk in enumerate(chunks):
    print(f"\nChunk {i+1}:")
    print(chunk)

输出结果显示数据块已成功创建：

The output shows that the chunks were successfully created:

Chunks:
Chunk 1:
The CTO was explaining that …
Chunk 2:
GenAISys relies on a generative AI model…
Chunk 3:
We defined memoryless, short-term, long-term…

剩余的嵌入和插入更新步骤与之前的步骤相同Pinecone_instruction_scenarios.ipynb——只需记住在编写向量时使用 ` namespace="data01"\begin{vector}` 即可。之后，我们就可以查询索引并验证检索结果了。

The remaining embedding and upsert steps are identical to those in Pinecone_instruction_scenarios.ipynb—just remember to use namespace="data01" when writing the vectors. After that, we’re ready to query the index and verify retrieval.

查询松果索引

Querying the Pinecone index

正如你现在，我们的向量存储包含两个逻辑区域——genaisys用于指令场景和data01用于经典数据。在本节中，我们将交互式地查询每个区域，以验证检索代码是否正常工作，然后再将其集成到第 4 章的多用户界面中。我们将查询 Pinecone 索引中的这两个命名空间，如图3.5所示：

As you know, our vector store now has two logical areas—genaisys for instruction scenarios and data01 for classical data. In this section, we’ll query each area interactively to prove the retrieval code works before we wire it into the multi-user interface in Chapter 4. We will query these two namespaces in the Pinecone index, as shown in Figure 3.5:

图 3.5：生成式 AI 模型查询指令场景或数据

Figure 3.5: Generative AI model querying either the instruction scenarios or the data

打开以运行验证查询。接下来的步骤与“设置环境”和“创建 Pinecone 索引”Query_Pinecone.ipynb部分中的步骤相同，只有两处细微差别：

Open Query_Pinecone.ipynb to run the verification queries. The next steps are the same as those in the Setting up the environment and Creating the Pinecone index sections, except for two minor differences:

• 连接到 Pinecone 索引时，不会提供命名空间，只会提供索引名称index_name = 'genai-v1'。这是因为查询函数会负责选择命名空间。
• The namespace is not provided when we connect to the Pinecone index, only its name: index_name = 'genai-v1'. This is because the querying function will manage the choice of a namespace.
• Upserting笔记本的这一部分已被删除，因为我们不是在执行 upsert 操作，而是在查询 Pinecone 索引。
• The Upserting section of the notebook has been removed because we are not upserting but querying the Pinecone index.

笔记本的这一Query部分分为两个小节。第一小节包含查询函数，第二小节包含查询请求。我们先从查询函数开始。

The Query section of the notebook is divided into two subsections. The first subsection contains the querying functions and the second one the querying requests. Let’s begin with the querying functions.

查询功能

Querying functions

共有四个查询函数如下：

There are four querying functions, as follows:

• QF1：query_vector_store(query_text, namespace)接收查询，将请求发送给 QF2，并返回响应。它将使用 QF4 显示结果。
• QF1: query_vector_store(query_text, namespace), which receives the query, sends the request to QF2, and returns the response. It will use QF4 to display the results.
• QF2：get_query_results(query_text, namespace)接收来自 QF1 的查询，将其发送到 QF3 进行嵌入，执行实际查询，并将响应返回给 QF1。
• QF2: get_query_results(query_text, namespace), which receives the query from QF1, sends it to QF3 to be embedded, makes the actual query, and returns a response to QF1.
• QF3：get_embedding(text, model=embedding_model)接收来自 QF2 的要嵌入的文本，并将嵌入的文本发送回 QF2。
• QF3: get_embedding(text, model=embedding_model), which receives text to embed from QF2 and sends the embedded text back to QF2.
• QF4：display_results(query_results)接收来自 QF1 的结果，对其进行处理，然后将其返回给 QF1。
• QF4: display_results(query_results), which receives the results from QF1, processes them, and returns them to QF1.

我们可以如图 3.6所示，通过创建两组函数来简化表示：

We can simplify the representation as shown in Figure 3.6 by creating two groups of functions:

• query_vector_store一个包含 QF1、 QF4 和 QF1的组display_results，其中 QF1 通过 QF2 查询向量存储并将结果返回以进行显示。
• A group with QF1, query_vector_store, and QF4, display_results, in which QF1 queries the vector store through QF2 and returns the results to display.
• 具有 QF2 的组get_query_results，在将查询嵌入 QF3 后查询向量存储get_embedding，并将结果返回给 QF1。
• A group with QF2, get_query_results, queries the vector store after embedding the query with QF3, get_embedding, and returns the results to QF1.

图 3.6：使用两组函数查询向量存储

Figure 3.6: Querying the vector store with two groups of functions

我们先来看第一组函数。

Let’s begin with the first group of functions.

查询向量存储并返回结果

Querying the vector store and returning results

这第一个函数 QF1 接收用户输入：

The first function, QF1, receives the user input:

def query_vector_store(query_text, namespace):
    print("Querying vector store...")

然后，函数调用 QF2 query_results，：

Then, the function calls QF2, query_results:

    # Retrieve query results
    query_results = get_query_results(query_text, namespace)

QF2 然后返回结果query_results，该结果又被发送到display_results以获取文本和目标 ID：

QF2 then returns the results in query_results, which, in turn, is sent to display_results to obtain the text and target ID:

    # Process and display the results
    print("Processed query results:")
    text, target_id = display_results(query_results)
    return text, target_id

display_results流程它接收到的查询结果和返回结果以及元数据，以在 Pinecone 索引的元数据中查找文本。找到后，该函数检索 ID：

display_results processes the query results it receives and returns the result along with metadata to find the text obtained in the metadata of the Pinecone index. When it is found, the function retrieves the ID:

def display_results(query_results):
    for match in query_results['matches']:
        print(f"ID: {match['id']}, Score: {match['score']}")
        if 'metadata' in match and 'text' in match['metadata']:
            text=match['metadata']['text']
            #print(f"Text: {match['metadata']['text']}")
            target_id = query_results['matches'][0]['id']  # Get the ID from the first match
            #print(f"Target ID: {target_id}")
        else:
            print("No metadata available.")
      return text, target_id

文本和 ID 会返回给 QF1， query_vector_storeQF1 再将结果返回给调用该函数的函数。请注意，出于教学目的，此函数假设文本query_results始终至少包含一个匹配项，'metadata'且匹配'text'字段为 `text` 和 `id`。现在让我们看看查询是如何处理的。

The text and ID are returned to QF1, query_vector_store, which, in turn, returns the results when the function is called. Note that for educational purposes, this function assumes query_results will always contain at least one match with 'metadata' and 'text' fields. Let’s now see how the query is processed.

处理查询

Processing the queries

这该程序使用提供的输入文本和命名空间查询 Pinecone 索引get_query_results。但首先，必须嵌入输入文本才能在向量存储中进行向量相似性搜索：

The program queries the Pinecone index with get_query_results with the input text and namespace provided. But first, the input text must be embedded to enable a vector similarity search in the vector store:

def get_query_results(query_text, namespace):
    # Generate the query vector from the query text
    query_vector = get_embedding(query_text)  # Replace with your method to generate embeddings

输入嵌入完成后，将对指定命名空间内的向量化输入进行向量搜索：

Once the input is embedded, a vector search is requested with the vectorized input within the namespace specified:

    # Perform the query
    query_results = index.query(
        vector=query_vector,
        namespace=namespace,
        top_k=1,  # Adjust as needed
        include_metadata=True
    )

请注意，本例中k设置为“1仅检索单个最佳结果以提高精度”，并且元数据设置为“True包含相应文本”。结果将返回给 QF2 query_results。

Note that k is set to 1 in this example to retrieve a single top result for precision, and also, the metadata is set to True to include the corresponding text. The results are returned to QF2,query_results:

    # Return the results
    return query_results

嵌入该函数与我们之前用于在 Pinecone 索引中插入数据的函数相同：

The embedding function is the same as what we used to upsert the data in the Pinecone index:

import openai
client = openai.OpenAI()
embedding_model = "text-embedding-3-small"
def get_embedding(text, model=embedding_model):
    text = text.replace("\n", " ")
    response = client.embeddings.create(input=[text], model=model)
    embedding = response.data[0].embedding
    return embedding

现在我们准备运行两个测试：指令场景查询（命名空间genaisys）和源数据查询（命名空间data01）。

We’re now ready to run two tests: an instruction scenario query (namespace genaisys) and a source data query (namespace data01).

检索查询

Retrieval queries

检索在指令执行场景中，我们将输入用户指令和命名空间，以便系统找到最接近的指令来执行：

To retrieve an instruction scenario, we will enter a user input and the namespace to let the system find the closest instruction to perform:

# Define your namespace and query text
namespace = "genaisys"  # Example namespace
query_text = "The customers like the idea of travelling and learning. Provide your sentiment."

系统应检测用户简要提出的任务请求，并返回完整的操作说明。为此，我们将调用函数的入口点，query_vector_store并显示返回的输出：

The system should detect the task briefly asked for and return a comprehensive instruction scenario. For that, we’ll call the entry point of the functions, query_vector_store, and display the output returned:

# Call the query function
text, target_id = query_vector_store(query_text, namespace)
# Display the final output
print("Final output:")
print(f"Text: {text}")
print(f"Target ID: {target_id}")

输出结果令人满意，可以用于第四章的对话循环中：

The output is satisfactory and is ready to be used in Chapter 4 in a conversational loop:

Querying vector store...
Processed query results:
ID: 2, Score: 0.221010014
Querying response time: 0.54 seconds
Final output:
Text: 200,Sentiment analysis  Read the content return a sentiment analysis nalysis on this text and provide a score with the label named : Sentiment analysis score followed by a numerical value between 0 and 1  with no + or - sign and  add an explanation to justify the score.
Target ID: 2

这程序现在从 Pinecone 索引中检索数据。由于命名空间是一个变量，因此查询函数完全相同。我们直接来看查询和输出。查询指向数据命名空间：

The program now retrieves data from the Pinecone index. The query functions are identical since the namespace is a variable. Let’s just look at the query and output. The query is directed to the data namespace:

# Define your namespace and query text
namespace = "data01"  # Example namespace
query_text = "What did the CTO say about the different types of memory?"
The result is printed:
# Display the final output
print("Final output:")
print(f"Text: {text}")
print(f"Target ID: {target_id}")

输出结果令人满意：

The output is satisfactory:

Querying vector store...
Processed query results:
ID: 3, Score: 0.571151137
Querying response time: 0.45 seconds
Final output:
Text: We defined memoryless, short-term, long-term memory, and cross-topic memory. For the hybrid travel marketing campaign, we will distinguish semantic memory (facts) from episodic memory (personal events in time, for example). The CTO said that we will need to use episodic memories of past customer trips to make the semantic aspects of our trips more engaging.
Target ID: 3

我们有因此，我们填充了一个 Pinecone 向量存储并对其进行了查询。在继续向 GenAISys 添加更多层之前，让我们先总结一下 Pinecone 索引的实现。

We have thus populated a Pinecone vector store and queried it. Let’s summarize the implementation of the Pinecone index before we move on to adding more layers to our GenAISys.

概括

Summary

在本章中，我们超越了传统的RAG（红绿灯）方法，将GenAISys项目向前推进了一步。首先，我们在源数据集之上叠加了专家编写的指令场景，将静态的RAG流程转变为动态框架，该框架不仅可以获取事实，还可以获取模型应遵循的精确推理模式。全球市场正以惊人的速度发展，用户现在期望在需要时立即获得ChatGPT级别的帮助；如果我们希望跟上时代的步伐，我们的架构必须灵活、成本可控，并且能够实现近乎实时的交付。

In this chapter, we pushed our GenAISys project another step forward by moving beyond ordinary RAG. First, we layered expert-written instruction scenarios on top of the source data corpus, turning a static RAG pipeline into a dynamic framework that can fetch not only facts but also the exact reasoning pattern the model should follow. The global market is accelerating so quickly that users now expect ChatGPT-level assistance the moment a need arises; if we hope to keep pace, our architecture must be flexible, cost-aware, and capable of near-real-time delivery.

我们首先构建了架构，然后引入收益递减规律，以确定何时隐式相似性搜索值得投入计算资源，何时直接显式调用（例如简单的网络搜索）成本更低。有了理论基础，我们编写了一个程序，用于下载、分块、嵌入和更新指令场景到 Pinecone 索引的专用命名空间中。接下来，我们利用 GPT-4o 对源文档执行相同的分块和嵌入操作，并将这些向量存储在第二个命名空间中。两个分区都构建完成后，我们验证了检索层：现在，只需一个查询函数即可将任何提示路由到正确的命名空间，并返回最佳匹配及其元数据。

We began by laying out that architecture, then introduced the law of diminishing returns to determine when an implicit similarity search is worth its compute bill and when a direct, explicit call—such as a simple web search—will do the job more cheaply. With the theory in place, we wrote a program to download, chunk, embed, and upsert the instruction scenarios into a dedicated namespace inside a Pinecone index. Next, we enlisted GPT-4o to perform the same chunk-and-embed routine on the source documents, storing those vectors in a second namespace. Once both partitions were in place, we verified the retrieval layer: a single query function now routes any prompt to the correct namespace and returns the best match along with its metadata.

GenAISys 拥有清晰分离且可即时搜索的场景和数据，具备所需的检索基础架构。在下一章中，我们将把这些组件集成到对话循环中，让系统展示其全面的、可用于业务场景的敏捷性。

With scenarios and data cleanly separated yet instantly searchable, the GenAISys has the retrieval backbone it needs. In the next chapter, we will plug these components into the conversational loop and let the system demonstrate its full, business-ready agility.

问题

Questions

1. 生成式人工智能系统可以实现所有任务的自动化，没有上限。（正确/错误）
1. There is no limit to automating all tasks in a generative AI system. (True or False)
2. 边际效益递减规律在人工智能领域没有用处。（正确或错误）
3. The law of diminishing returns is of no use in AI. (True or False)
4. 分块是将数据分解成更小的部分以提取更细致信息的过程。（正确或错误）
5. Chunking is the process of breaking data into smaller parts to retrieve more nuanced information. (True or False)
6. 你只能使用一种嵌入模型。（正确或错误）
7. There is only one embedding model you should use. (True or False)
8. 将数据更新插入到 Pinecone 索引中意味着将数据上传到数据库。（正确或错误）
9. Upserting data to a Pinecone index means uploading data to a database. (True or False)
10. 命名空间是数据库的名称。（正确或错误）
11. A namespace is the name of a database. (True or False).
12. 命名空间可用于访问不同类型的数据。（正确或错误）
13. A namespace can be used to access different types of data. (True or False)
14. 查询 Pinecone 索引需要嵌入用户输入。（正确或错误）
15. Querying the Pinecone index requires the user input to be embedded. (True or False)
16. 查询松果指数是基于余弦相似度等指标。（正确或错误）
17. Querying the Pinecone index is based on a metric such as cosine similarity. (True or False)
18. Pinecone索引和查询函数是GenAISys仅有的组成部分。（正确或错误）
19. The Pinecone index and the query functions are the only components of a GenAISys. (True or False)

参考

References

• OpenAI 嵌入文档：https://platform.openai.com/docs/guides/embeddings
• OpenAI embeddings documentation: https://platform.openai.com/docs/guides/embeddings
• Pinecone Python SDK 文档：https://docs.pinecone.io/reference/python-sdk
• Pinecone Python SDK documentation: https://docs.pinecone.io/reference/python-sdk
• Pinecone 文档：https://docs.pinecone.io/guides/get-started/overview
• Pinecone documentation: https://docs.pinecone.io/guides/get-started/overview

延伸阅读

Further reading

• 人工智能开发成本：了解人工智能解决方案的开发成本构成：https://www.spaceo.ai/blog/ai-development-cost/
• AI Development Cost: Learn What Makes Developing an AI Solution: https://www.spaceo.ai/blog/ai-development-cost/

• 立即解锁本书的专属权益 扫描此二维码或访问packtpub.com/unlock，然后按书名搜索本书。
  注意：开始之前请准备好您的采购发票。

• Unlock this book’s exclusive benefits now Scan this QR code or go to packtpub.com/unlock, then search for this book by name.
  Note: Keep your purchase invoice ready before you start.

4

4

构建 AI 控制器编排接口

Building the AI Controller Orchestration Interface

如今，企业需要以前所未有的速度设计、生产和交付商品及服务。从在线云服务到食品、药品、服装等配送，响应速度几乎已成为所有领域的关键。这种事件驱动型经济会产生源源不断的任务，而只有同样以事件驱动、以人为本的生成式人工智能系统（GenAISys）才能跟上步伐。

Businesses today need to design, produce, and deliver goods and services at a speed never attained before. Responsiveness has become key in nearly every field, from online cloud services to delivering food, medication, clothing, and so on. Such an event-driven economy produces an endless stream of tasks, and only an equally event-driven, human-centered generative AI system (GenAISys) can keep pace.

即使是自动化程度最高的流程，也仍然离不开人类的判断：当火灾发生、风暴摧毁基础设施或供应链中断时，必须依靠团队而非算法采取行动。一个将人排除在外的先进全息人工智能系统（GenAISys）只是一个神话。因此，本章首先概述了一种打破用户与人工智能之间壁垒的架构，旨在创建一个协作式的多用户聊天机器人。

Human judgment still anchors even the most automated workflows: when fires break out, storms destroy infrastructure, or supply chains falter, teams—not algorithms alone—must act. An advanced GenAISys that leaves people out of the loop is a myth. This chapter, therefore, begins by outlining an architecture that tears down the walls between users and AI to create a collaborative, multi-user chatbot.

首先，我们从宏观层面概述事件驱动的 GenAISys 接口，展示前几章中提到的构建模块——短期记忆、情景记忆和长期记忆、多轮对话代理以及用于指令场景和数据的双 RAG 流水线——是如何协同工作的。为了实现响应式系统，我们需要编写 GenAISys 的进程代码，以及管理生成式 AI 代理的对话代理代码。GenAISys 接口构建完成后，我们将运行一个多用户、多轮对话，对话对象为三位在一家在线旅行社工作的用户。他们的在线会议将包含一个对话式 AI 代理作为参与者。

First, we sketch the event-driven GenAISys interface at a high level, showing how the building blocks from earlier chapters—short-term, episodic, and long-term memory, the multi-turn conversational agent, and twin RAG pipelines for instruction scenarios and data—fit together. To then implement the responsive system, we must code the processes of the GenAISys and then the conversational agent that will manage the generative AI agent. Once our GenAISys interface is built, we will run a multi-user, multi-turn conversation with three users working in an online travel agency. Their online meeting will include a conversational AI agent as a participant.

这些用户将能够与人工智能代理进行在线会议，无论是否使用人工智能代理。他们可以利用 RAG 查找教学场景，或者直接向生成式人工智能代理提问。在本章结束时，我们将拥有一个功能齐全的 GenAISys 接口，为第五章中的多模态思维链扩展做好准备。

These users will be able to have an online meeting with or without the AI agent. They will be able to utilize RAG to find instruction scenarios or simply ask the generative AI agent to answer a question. By the end of the chapter, we will have a fully working GenAISys interface ready for the multimodal chain-of-thought extensions in Chapter 5.

简而言之，本章涵盖以下主题：

In a nutshell, this chapter covers the following topics:

• 事件驱动型 GenAISys 接口架构的高级视图
• A high-level view of the architecture of an event-driven GenAISys interface
• GenAISys接口的底层操作流程图
• A low-level, hands-on flowchart of the GenAISys interface
• 为输入、AI代理和活跃用户实现响应组件
• Implementing response widgets for inputs, the AI agent, and active users
• 聊天机器人在多轮对话中的事件驱动流程
• The chatbot’s event-driven flow in a multi-turn conversation
• 以人工智能代理为参与者的多用户 GenAISys 对话
• Multi-user GenAISys conversation with an AI agent as a participant
• 对话代理的响应 RAG 特征
• The response RAG features of the conversational agent
• GenAISys接口和AI代理的编排能力
• The orchestration capabilities of the GenAISys interface and AI agent

我们的首要任务是定义一个事件驱动的 GenAISys 接口。

Our first task is to define an event-driven GenAISys interface.

事件驱动型 GenAISys 接口的架构

Architecture of an event-driven GenAISys interface

我们基于事件驱动的GenAISys接口集成了我们在前几章中构建的功能。界面将利用 IPython 小部件的灵活性来创建一个响应式事件驱动环境，其中适用以下规则：

Our event-driven GenAISys interface integrates the functionality we built in the previous chapters. The interface will leverage the flexibility of IPython widgets to create a reactive event-driven environment in which the following apply:

• 高层任务将由事件驱动，由用户输入触发。
• The high-level tasks will be event-driven, triggered by user inputs
• 生成式人工智能任务将触发生成式人工智能代理功能
• Generative AI tasks will trigger generative AI agent functions

我们将首先从宏观层面审视我们正在构建的程序，如图4.1所示：

We will first examine the program we are building at a high level, as represented in Figure 4.1:

图 4.1：GenAISys 接口的高级架构

Figure 4.1: High-level architecture of the GenAISys interface

让我们回顾一下前几章中已经实现的功能，并列出本章要添加的关键功能：

Let’s go through the functions we have already built in the previous chapters and also list the key ones we are adding in this chapter:

• I1 – AI 控制器：本章的主要新组件是具有响应式小部件的生成式 AI Python 接口，它将作为 AI 控制器和编排器运行。
• I1 – AI controller: This chapter’s main new component is the generative AI Python interface with responsive widgets, which will be run as an AI controller and orchestrator
• I2 – 多用户聊天机器人：多个用户同时交互的聊天界面
• I2 – Multi-user chatbot: The chat surface through which several users interact concurrently
• F1 – 生成式人工智能模型：继承自之前所有章节，特别是第 3 章，我们在该章中使用 GPT-4o 运行了生成式人工智能调用。
• F1 – Generative AI model: Inherited from all the previous chapters, especially Chapter 3, in which we ran generative AI calls with GPT-4o
• F2 – 记忆保持：继承自第一章，第一章介绍了不同类型的记忆。
• F2 – Memory retention: Inherited from Chapter 1, which introduced different types of memory
• F3 – 模块化 RAG ：继承自第 3 章的指令和数据流水线
• F3 – Modular RAG: The instruction-and-data pipelines inherited from Chapter 3
• F4 – 多功能性：第2章和第 3章中的语义和情感分析，将在第 5 章中扩展，增加图像、音频、网络搜索和机器学习功能。
• F4 – Multifunctional capabilities: Semantic and sentiment analysis from Chapters 2 and 3, to be expanded in Chapter 5 with image, audio, web search, and ML features

建造对于这种架构，我们将执行以下操作：

To build this architecture, we will do the following:

• 构建事件驱动型 GenAISys 接口的流程
• Build the processes of an event-driven GenAISys interface
• 使用 GPT-4o 和 OpenAI 嵌入模型实现对话代理
• Implement the conversational agent with GPT-4o and an OpenAI embedding model
• 运行一个多用户、多回合的会话，探索 GenAISys AI 控制器和编排器的主要功能。
• Run a multi-user, multi-turn session exploring the main features of the GenAISys AI controller and orchestrator

我们先来探讨一下场景驱动的任务执行。

Let’s first explore scenario-driven task execution.

构建事件驱动型 GenAISys 接口的流程

Building the processes of an event-driven GenAISys interface

首先，我们使用 IPython 小部件来构建如图 4.2所示的 GenAISys 界面。响应式、事件驱动的环境。最终将呈现一个动态的多用户聊天界面，包含下拉菜单、文本输入框和复选框——满足用户与生成式人工智能代理之间实时协作所需的一切。

Let’s begin by building the GenAISys interface shown in Figure 4.2, using IPython widgets to create a responsive, event-driven environment. The result will be a dynamic multi-user chat surface with drop-down menus, text-input fields, and a checkbox—everything needed for real-time collaboration between people/users and the generative AI agent.

打开Event-driven_GenAISys_framework.ipynbGitHub 上 Chapter04 目录下的 notebook 文件（https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main）。环境设置与前几章所述相同：

Open Event-driven_GenAISys_framework.ipynb notebook within the Chapter04 directory on GitHub (https://github.com/Denis2054/Building-Business-Ready-Generative-AI-Systems/tree/main). Setting up the environment is the same as described in the previous chapters:

• 要设置 OpenAI，请参阅第 1 章，包括此处使用的自定义 OpenAI API 调用：openai_api.make_openai_api_call
• To set up OpenAI, refer to Chapter 1, including the custom OpenAI API call used here: openai_api.make_openai_api_call
• 请参阅第 3 章，了解如何设置 Pinecone、连接到索引以及查询索引。
• Refer to Chapter 3 for setting up Pinecone, connecting to the index, and querying it

ipythonnotebook 环境需要额外的软件包（ ）。IPython 已预装在 Google Colab 中；如果需要，请使用以下命令安装：

An additional package (ipython) is required for the notebook environment. IPython is pre-installed in Google Colab; if needed, install it using the following:

!pip install ipython

我们将构建的代码演示了事件驱动交互、动态内容更新和模块化功能组织等核心概念。在本节结束时，您将学习如何弥合人工智能功能与最终用户互动之间的差距。

The code we’ll build demonstrates core concepts such as event-driven interactions, dynamic content updating, and modular function organization. By the end of this section, you will have learned how to bridge the gap between AI functionality and end user engagement.

图 4.2：事件驱动型 GenAISys 接口的流程图

Figure 4.2: The flowchart of an event-driven GenAISys interface

主要构建此界面所需的功能组如下：

The main groups of functions required to build this interface are the following:

• 初始化控件
• Initializing widgets
• 处理用户输入和选择更改
• Handling user input and selection changes
• 处理聊天消息，包括触发函数和退出命令
• Processing chat messages, including triggering functions and exit commands
• 生成和处理人工智能响应
• Generating and processing AI responses
• 动态更新用户界面
• Updating the UI dynamically
• 保存对话历史记录
• Saving the conversation history

在从开发者的角度深入研究代码之前，让我们先从用户的角度出发。我们必须构建一个直观的界面，能够无缝执行图 4.2中概述的流程。

Before diving into the code from a developer’s perspective, let’s keep the user’s point of view in mind. We must build an intuitive interface that can seamlessly execute the flow outlined in Figure 4.2.

图 4.3：用户视角下的 GenAISys

Figure 4.3: GenAISys from a user’s perspective

用户界面仅包含三个小部件：用于输入提示的输入框、用于选择活跃用户的下拉列表以及用于激活和停用对话式 AI 代理的复选框。

The UI contains only three widgets: an input box for entering prompts, a drop-down list for selecting active users, and a checkbox for activating and deactivating the conversational AI agent.

让我们一起来了解一下如何设置和运行这个交互式 GenAISys 环境。

Let’s walk through the process of setting up and running this interactive GenAISys environment.

1. 开始

1. Start

该程序从多用户对话开始，代理作为参与者单元。我们首先导入所需的模块和库，从以下代码开始IPython：

The program starts from the Multi-user conversation with the agent as a participant cell. We first import the modules and libraries we need, starting with IPython:

from IPython.display import display, HTML, clear_output

让我们逐一了解将在 Google Colab 中实现的各项功能：

Let’s go through each functionality we will be implementing in Google Colab:

• display并HTML显示诸如小部件、图像和富 HTML 输出之类的对象
• display and HTML to display objects such as widgets, images, and rich HTML outputs
• clear_output清除单元格的输出
• clear_output to clear the output of a cell

然后，我们导入ipywidgets由 Jupyter 项目管理的模块：

Then, we import ipywidgets managed by the Jupyter project:

from ipywidgets import Dropdown, Text, Checkbox, VBox, Layout

ipywidgets是核心这是本笔记本中交互式界面的一个组成部分，我们将使用以下控件：

ipywidgets is the core component of the interactive interface in this notebook, in which we will use the following widgets:

• Dropdown：一个下拉菜单控件，用于从选项列表中选择一个值。
• Dropdown: A drop-down widget to select a value from a list of options
• Text用户输入文本的小部件
• Text: A widget for text input from a user
• Checkbox用于布尔值选中/未选中输入的控件
• Checkbox: A widget for Boolean checked/unchecked input
• Vbox一个用于以垂直盒式布局排列子组件的容器组件
• Vbox: A container widget to arrange child widgets in a vertical box layout
• Layout：通过宽度、高度和边距等布局属性自定义小部件的样式
• Layout: To customize the style of the widgets with layout properties such as width, height, and margin

最后，我们导入 JSON，用于存储多用户对话历史记录：

Finally, we import JSON, used to store multi-user conversation histories:

import json

然后，我们初始化所有用户的对话历史记录，定义第一个活跃用户，并将活跃对话设置为True：

We then initialize the conversation histories for all users, define the first active user, and set the active conversation to True:

# Initialize conversation histories for all users and active user
user_histories = {"User01": [], "User02": [], "User03": []}
active_user = "User01"  # Default user
conversation_active = True

因此，从一开始，我们就着手构建一个多用户协作的 GenAISys 系统，用户可以在其中进行交互。可以是人工提示，也可以是系统提示。例如，“用户”可以是来自其他系统的消息，并在此界面中由读取待处理消息的事件触发。用户列表可以扩展、存储在变量中，或用于任何符合项目需求的用户管理系统，包括访问权限、密码以及各种应用程序的角色。接下来，我们初始化组件本身。

We are thus, from the start, initializing a multi-user collaborative GenAISys in which the users can be human prompts and system prompts. For example, a “user” could be a message from another system and triggered in this interface by an event that reads pending messages. The user list can be expanded, stored in variables, or utilized in any user management system that suits a project’s needs, including access rights, passwords, and roles for various applications. Next, we initialize the widgets themselves.

2. 初始化小部件

2. Initialize widgets

现在，代码会设置我们需要的Dropdown、Text和Checkbox小部件。这些小部件也与事件处理程序关联。Dropdown用户小部件定义了对话开始时初始化的三个用户：

The code now sets up the Dropdown, Text, and Checkbox widgets we need. The widgets are also linked to event handlers. The Dropdown widget for the users defines the three users initialized at the start of the conversation:

# Create a dropdown to select the user
user_selector = Dropdown(
    options=["User01", "User02", "User03"],
    value=active_user,
    description='User:',
    layout=Layout(width='50%')
)

该选择器有四个参数：

The selector has four parameters:

• options列出可扩展的可用用户，并可根据项目需要访问任何用户管理存储库。
• options lists the available users that can be expanded and can access any user management repository as needed for your project.
• value确定当前活动用户。程序启动时默认User01使用初始用户。当授权用户首次连接到 GenAISys 时，此过程可以自动完成。
• value determines the active user. The program started with User01 as the initial user. This can be automated when an authorized user first connects to the GenAISys.
• description为要显示的下拉列表提供标签。
• description provides a label for the drop-down list that will be displayed.
• layout设置要显示的控件的宽度。
• layout sets the width of the widget that will be displayed.

请注意，我们正在构建的是 GenAISys 的核心，而非平台。我们的目标是掌握 GenAISys 的内部运作机制。一旦它按预期运行，我们就可以添加传统的用户管理层（名称、角色和权限）。在这种情况下，我们始终专注于 GenAISys 灵活的核心概念，而不是如何将它们封装到特定的平台和框架中。我们正在学习如何成为生成式 AI 智能体的架构师，而不是特定框架的运维者。

Note that we are creating a core GenAISys, not a platform. The goal is to grasp the inner workings of a GenAISys. Once it works as expected, we can then add the classical layers of user management (names, roles, and rights). In this case, we are remaining focused on the flexible core concepts of GenAISys, not how they will be encapsulated in a specific platform and framework. We are learning how to be generative AI agentic architects, not operators of a specific framework.

下一步是插入事件处理程序。在本例中，它是一个事件监听器，用于检测值何时user_selector发生变化。当选择另一个用户时，该on_user_change函数会自动调用，并将value用户切换到新用户：

The next step is to insert an event handler. In this case, it is an event listener that will detect when the value of user_selector changes. When another user is selected, the on_user_change function is automatically called, and value becomes the new user:

user_selector.observe(on_user_change, names='value')

GenAISys对话中用户的这种动态变化代表着一次重大的演变。一对一聊天机器人。它为以人工智能为共同参与者的协作团队工作引入了一个全新的维度。

This dynamic change in users within a GenAISys conversation represents a major evolution from the one-on-one chatbots. It introduces a whole new dimension to collaborative teamwork with AI as a co-participant.

第二个要激活的控件是输入控件：

The second widget to activate is the input widget:

# Create the input box widget
input_box = Text(placeholder="Type your message here or type 'exit' to end the conversation.", layout=Layout(width='100%'))

输入框可以是任何文本，并将占据 100% 的 UI 布局。当用户输入“是exit”或“否”时，对话结束quit。当输入文本并按下Enter键时，事件处理程序将接管控制权：

The input can be any text and will occupy 100% of the UI layout. The conversation ends when a user enters exit or quit. When the text is typed and the Enter button is pressed, the event handler takes over:

input_box.on_submit(handle_submit)  # Attach the on_submit event handler

on_submit是一个input_box该组件的方法handle_submit是一个回调函数，我们可以根据需要编写它，稍后将在本节中进行描述。

on_submit is a method of the input_box widget. handle_submit is a callback function that we can write as we wish and will be described later in this section.

第三个组件是用于启用人工智能对话代理的复选框：

The third widget is the checkbox for the AI conversational agent:

# Create a checkbox to toggle agent response
agent_checkbox = Checkbox(
    value=True,
    description='Agent',
    layout=Layout(width='20%')
)

该复选框显示描述标签，在本例中指的是一个代理。布局将占据用户界面 20% 的空间。如果value设置为 true ，则会激活对话式 AI 代理。我们将在本章的“对话式代理”True部分构建该 AI 代理。该 AI 代理还将采用事件驱动机制。

The checkbox displays the description label, which is an agent in this case. The layout will occupy 20% of the UI. If value is set to True, then the conversational AI agent will be activated. We will build the AI agent in the Conversational agent section of this chapter. The AI agent will also be event-driven.

用户界面框现在可以显示了。

The UI box is now ready to be displayed.

3. 显示用户界面

3. Display the UI

用户界面VBox容器组件现在整合了我们在（V表示垂直；即，在一个垂直的盒子中）定义的三个事件驱动组件。这三个组件用括号括起来：

The UI container widget now combines the three event-driven widgets we defined in VBox (V stands for vertical; i.e., in a vertical box). The three widgets are in brackets:

# Display the initial interface
display(
    VBox(
        [user_selector, input_box, agent_checkbox],
        layout=Layout(
            display='flex', flex_flow='column',
            align_items='flex-start', width='100%'
        )
    ))

然后定义布局：

The layout is then defined:

layout=Layout(
    display='flex', flex_flow='column',
    align_items='flex-start', width='100%'
)))

此响应式用户界面的参数如下：

The parameters of this responsive UI are the following:

• display='flex'动态激活 CSS Flexbox 模型进行布局，而无需指定元素的大小。
• display='flex' activates the CSS flexbox model for layouts dynamically without specifying the sizes of the items
• flex_flow='column'垂直排列子控件
• flex_flow='column' arranges the child widgets vertically
• align_items='flex-start'将控件对齐到 UI 容器的起始位置（左侧）
• align_items='flex-start' aligns the widgets to the start (left side) of the UI (left side) container
• width='100%'使容器占据可用空间的全部宽度
• width='100%' makes the container take up the full width of the available space

至此，用户界面已准备就绪。我们可以选择从三个组件中的任意一个开始。用户选择器和AI代理复选框都可以在输入框之前运行。在本例中，用户选择器User01和AI代理复选框均设置为默认值True。

With that, the UI is ready. We can choose to begin with any of the three widgets. The user selector can be run before the input, as well as the AI agent checkbox. In this case, the user selector was set to a default value, User01, and the AI agent checkbox was set to the default value, True.

根据项目需求，这三个组件及其相关流程可以集成到任何经典的网页或软件界面中。由于输入没有默认值，我们继续讨论输入组件。

The three widgets and their processes can be built into any classical web or software interface, depending on your project’s needs. Since there is no default value for the input, let’s continue with the input widget.

4. 输入框事件

4. Input box event

输入文本由上一节所述的用户界面进行管理，该用户界面会input_box.on_submit(handle_submit)在用户输入文本时触发。随后，该submit方法会调用以下handle_submit函数：

The input text is managed by the UI described in the previous section, which triggers input_box.on_submit(handle_submit) when a user enters text. In turn, the submit method calls the handle_submit function:

# Function to handle the submission of the input
def handle_submit(sender):
    user_message = sender.value
    if user_message.strip():
        sender.value = ""  # Clear the input box
        chat(user_message)

现在，该函数执行三项操作：

Now, the function does three things:

• user_message = sender.value处理从输入控件接收的文本
• user_message = sender.value processes the text received from the input widget
• if user_message.strip()检查是否有消息，并清除输入框以便进行下一次输入。sender.value = "" # Clear the input box
• if user_message.strip() checks whether there is a message and clears the input box for the next input with sender.value = "" # Clear the input box
• chat(user_message)如果有消息，则会调用此函数。
• chat(user_message) is called if there is a message

chat(user_message)这是GenAISys的下一个流程，也是一个关键的事件处理中心。让我们一起来了解一下。

chat(user_message) is the next process and a key event processing hub for the GenAISys. Let’s go through it.

5. chat(user_message) 函数

5. chat(user_message) function

该chat(user_message)函数是我们事件驱动型 GenAISys 的一个协调器组件。它应该继续以人为本，以服务于关键的人类需求。控制。一旦系统获得用户信任并经过仔细考虑，其管理的某些操作可以由系统消息触发。协调器在处理从函数接收到的用户消息时会做出重要决策。它封装了多个选择和功能，如图 4.2handle_submit(sender)所示：决定是否继续对话、将对话历史记录追加或保存到文件、确定是否调用 AI 对话代理以及更新 UI 显示。

The chat(user_message) function is an orchestrator component of our event-driven GenAISys. It should remain human-centered for critical human control. Once the system has gained the trust of the users and after careful consideration, some of the actions it manages can be triggered by system messages. The orchestrator contains important decisions when it processes the user message it receives from the handle_submit(sender) function. It encapsulates several choices and functions, as represented in Figure 4.2: deciding whether to continue the conversation, appending or saving the conversation history to a file, determining whether to call the AI conversational agent, and updating the UI display.

conversation_active = True它首先继承了我们在对话开始时初始化的对话变量（）的全局状态（在图 4.2的节点1中）：

It first inherits the global status of the conversation variable (conversation_active = True) we initialized at the start of the conversation (in node 1 of Figure 4.2):

# Function to handle user input and optional bot response
def chat(user_message):
    global conversation_active

它会继续检查用户是否已退出或结束对话，以确定多轮对话是否结束（参见图 4.2中的6）：

It continues to determine whether the multiple-turn conversation is over or not by checking whether the user has exited or quit the conversation (see 6 in Figure 4.2):

        if user_message.lower() in ['exit', 'quit']:

让我们看看如果用户选择退出对话会发生什么。

Let’s see what happens if the user chooses to exit the conversation.

6. 如果选择“退出”

6. If ‘exit’ is chosen

假设用户输入exit“或” quit；那么conversation_active我们将变量设置为True“”。对话开始时间（图 4.2中的节点1）现在将被设置为。系统现在知道无需再更新显示。然后，它指示函数等待下一轮对话，以清除输出，从而避免闪烁：Falseclear_output

Suppose the user enters exit or quit; then the conversation_active variable we set to True at the start of the conversation (in node 1 of Figure 4.2) will now be set to False. The system now knows that there is no need to update the display anymore. It then tells the clear_output function to wait until the next conversation turn to clear the output to avoid flickering effects:

clear_output(wait=True)

退出过程会继续显示一条消息，表明对话结束，并提示对话历史记录正在保存：

The exit process continues by displaying a message signaling the end of the conversation and indicating that the conversation history is being saved:

display(HTML("<div style='color: red;'><strong>Conversation ended. Saving history...</strong></div>"))

退出过程以调用对话的保存函数结束，该函数会将所有历史记录保存到文件中（参见图 4.2中的节点7）：

The exit process ends by calling the save function of the conversation, which will save all history to a file (see node 7 in Figure 4.2):

save_conversation_history()

因此，会话结束时会保存对话内容以供后续使用（用于新会话或会议摘要），如图 4.2中的节点7所示：

The conversation is thus saved at the end of the session for further use (for a new session or a meeting summary), as shown in node 7 of Figure 4.2:

# Function to save conversation history to a file
def save_conversation_history():
    filename = "conversation_history.json"  # Define the filename
    with open(filename, 'w') as file:
        json.dump(user_histories, file, indent=4)  # Write the user histories dictionary to the file in JSON format
    display(HTML(f"<div style='color: green;'><strong>Conversation history saved to {filename}.</strong></div>"))

现在，让我们来看看用户选择继续对话时的过程。

Now, let’s go through the process when the user(s) chooses to continue the conversation.

7. 如果用户继续对话

7. If user(s) continue the conversation

如果用户输入不包含exit`or` quit，则多轮多用户对话将继续进行。然而，关于这个功能，我们需要做出一些重要的决定。我们是否要将其添加到 `是否应该每次用户请求都添加令牌？如果每次用户请求都添加令牌，上下文窗口最终会填满，但通过 API 发送的令牌数量会增加处理时间和成本。

If the user input does not contain exit or quit, then the multi-turn, multi-user conversation will continue. We have some big decisions to make with this function, however. Do we append it to each user request or not? If we append it to each user request, at some point, the context window will be complete, but the number of tokens we send through the API will increase processing time and costs.

第一步是将我们在开始时初始化的对话历史记录（图 4.2中的节点1）附加到此处：

The first step is to append the history of the conversation we initialized at the start (in node 1 of Figure 4.2):

# Append user message to the active user’s history 
user_histories[active_user].append(
    {“role”: “user”, “content”: user_message}
)

因此，在本笔记本的混合场景中，我们会将用户历史记录保存在内存中直至会话结束，从而将每个用户的输入与其历史记录进行合并，如图4.2中的节点11所示。如果用户输入不包含“或” ，则多轮多用户对话将继续进行，并将用户消息追加到该用户的历史记录中（如图 4.2中的节点8所示）。exitquit

So, in the hybrid scenario of this notebook, at this point, we will save the user history in memory until the end of the session, and we will thus augment each user’s input with their input history, as seen in node 11 of Figure 4.2. If the user input does not contain exit or quit, then the multi-turn, multi-user conversation will continue. It will append the user message to the history (in node 8 of Figure 4.2) of the user.

但是，如果我们不想将用户请求附加到对话记录中，但仍想保留整个对话的上下文信息，我们也可以在对话进行到一半或结束时进行总结。如果在对话过程中进行总结，我们可以添加一个函数将其附加到用户记录中。每次都需要输入。如果我们在会话结束后进行总结，就可以带着上一会话的历史记录摘要开始新的会话。

However, if we don’t want to append a user request to it but still want to keep a record of the entire conversation for context, we can also summarize the conversation at the midpoint or the end. If we summarize it during the conversation, we can add a function to append it to the user input each time. If we summarize after the end of a session, we can continue with a new, fresh session with a summary of the previous session’s history.

在本笔记本中，我们将实现一个混合短期和长期记忆的过程。我们可以通过不输入“是”'quit'或“否”来继续对话'exit'。现在，该chat(user_message)函数将检查对话代理的复选框值：

In this notebook, we will implement a hybrid short- and long-term memory process. We can continue the conversation by not entering 'quit' or 'exit'. Now, the chat(user_message) function will check the conversational agent’s checkbox value:

if agent_checkbox.value:

此验证过程如图 4.2中的节点9所示。如果选中复选框，则通过调用以下函数激活我们在前几章中创建的函数：chat_with_gpt

This verification is shown in node 9 in Figure 4.2. If the checkbox is checked, then the functions we created in the previous chapters are activated by calling chat_with_gpt:

    response = chat_with_gpt(user_histories[active_user],
        user_message)
 

响应返回后，会将其添加到前面描述的响应历史记录中：

Once the response is returned, it is appended to the history of the response described previously:

        user_histories[active_user].append( 
            {“role”: “assistant”, “content”: response} 
        ) 

我们现在有了一个入口点内存框架。程序随后调用了另一个关键函数，如图 4.2中的节点14update_display()所示。如果选中了代理复选框，则会调用该函数。chat_with_gpt

We now have an entry-point memory framework. The program then calls update_display(), another key function that is shown in node 14 of Figure 4.2. If the agent checkbox is checked, chat_with_gpt will be called.

8. 生成机器人回复

8. Generate bot response

该chat_with_gpt函数整合了我们在前几章中所做的工作，以创建一个对话式的文本。具备基于 Pinecone 的 RAG 功能的 AI 代理。我们将在本章的对话代理部分全面实现此集成。

The chat_with_gpt function assembles the work we did in the previous chapters to create a conversational AI agent with the Pinecone-based RAG functionality. We will fully implement this integration in the Conversational agent section of this chapter.

chat_with_gpt通过提供信息来协调人工智能对话代理，使其能够动态响应。本次对话的用户历史记录和用户消息将被发送给chat_with_gpt对话代理函数：

chat_with_gpt orchestrates the AI conversational agent by providing information, enabling it to be dynamic and responsive. The user history of this conversation and the user message are sent to the chat_with_gpt conversational agent function:

response = chat_with_gpt(user_histories[active_user], user_message)

一旦返回响应，update_display就会从调用该函数chat(user_message)。

Once the response is returned, the update_display function is called from chat(user_message).

9. 更新显示

9. Update display

该update_display功能会刷新用户界面，显示更新后的对话历史记录，并且wait显示控件的状态。它首先通过设置以下值来告诉 UI 等待新的输出到达True：

The update_display function refreshes the UI with the updated conversation history and also displays the status of the widgets. It first tells the UI to wait until a new output arrives by setting wait to True:

def update_display():
    clear_output(wait=True)

然后该函数筛选并显示当前用户的历史记录（参见图 4.2中的节点15）：

The function then filters and displays the active user’s history (see node 15 of Figure 4.2):

    for entry in user_histories[active_user]:  # Show only the active user's history
        if entry['role'] == 'user':
            display(HTML(f"<div style='text-align: left; margin-left: 20px; color: blue;'><strong>{active_user}:</strong> {entry['content']}</div>"))
        elif entry['role'] == 'assistant':
            display(HTML(f"<div style='text-align: left; margin-left: 20px; color: green;'><strong>Agent:</strong> {entry['content']}</div>"))

如果对话处于活动状态，VBox则会显示用户界面以及组件的状态：

If the conversation is active, the UI VBox is displayed along with the status of the widgets:

    if conversation_active:
        display(VBox([user_selector, input_box, agent_checkbox]))  # Keep input box, selector, and checkbox visible if active

输入框已清空，用户已自主勾选代理复选框，系统已验证其状态。当前用户将根据用户的自主选择显示。在本例中，对话active_user开始时初始化的当前用户（即1on_user_change ）保持不变。如果用户发生更改，则下拉事件 （13observe ）将由控件的方法触发user_selector：

The input box is cleared, the agent checkbox has been checked independently by the user, and the system has verified its status. The active user will be displayed based on the independent decision of the user. In this case, the active user, active_user, who was initialized at the start (1) of the conversation, remains the same. If the user changed, the on_user_change drop-down event (13) would have been triggered by the observe method of the user_selector widget:

user_selector.observe(on_user_change, names='value')

在这种情况下，user_selector.observe将独立调用update active_user函数（14），并首先确保活动用户是一个全局变量：

In that case, user_selector.observe will independently call the update active_user function (14) and first make sure that the active user is a global variable:

def on_user_change(change):
    global active_user

然后，它将将新用户设为活动用户：

Then, it will make the new user the active user:

    active_user = change['new']

最后，它将调用update_display我们在本小节中构建的函数：

Finally, it will call the update_display function we built in this subsection:

    update_display()

现在我们已经有了动态用户界面和事件驱动功能，接下来让我们实现由 调用的对话代理逻辑chat_with_gpt。

Now that we have our dynamic UI and event-driven functions in place, let’s implement the conversational agent logic called by chat_with_gpt.

对话代理

Conversational agent

我们在第 1 章和第2章实现了一个 AI 对话代理，并在第 3 章构建了查询 Pinecone 功能。请转到笔记本中的“对话代理”部分。如有需要，请参考……在继续之前，是时候回顾一下前面的章节了。在本节中，我们将整合这些组件，为 GenAISys 对话代理的多用户会话做好准备。

We implemented an AI conversational agent in Chapters 1 and 2 and built the query Pinecone functionality in Chapter 3. Go to the Conversational agent section of the notebook. If needed, take the time to revisit those chapters before proceeding. In this section, it’s time we integrate those components, preparing our GenAISys conversational agent for multi-user sessions.

我们首先导入 OpenAI 并初始化客户端：

We begin by importing OpenAI and initializing the client:

from openai import OpenAI
# Initialize the OpenAI client
client = OpenAI()

接下来，我们决定是否存储每次通话的所有用户对话历史记录，以优化上下文窗口大小，从而提高成本和清晰度：

Next, we make a decision to store or not to store all of the user’s conversation history for each call to optimize context window size for cost and clarity:

user_memory = True # True=User messages are memorized False=User messages are not memorized

在生产环境中，应策略性地监控内存设置。例如，这里我们将其设置user_memory为True，但我们避免在 RAG 查询期间应用它，因为历史上下文可能会干扰 Pinecone 相似性搜索。然后，我们定义函数，该函数在图 4.2的节点10chat_with_gpt中被调用：

The memory setting should be strategically monitored in production environments. For example, here we set user_memory to True, but we avoid applying it during RAG queries, as historical context could confuse the Pinecone similarity searches. We then define the chat_with_gpt function, which is called in node 10 of Figure 4.2:

def chat_with_gpt(messages, user_message):

该函数首先在输入文本中搜索关键字，以触发从 Pinecone 索引中检索 RAG 数据，具体实现Query_Pinecone.ipynb和描述见第 3 章。代码首先确定命名空间：

The function first searches the input text for a keyword to trigger a RAG retrieval from the Pinecone index as implemented in Query_Pinecone.ipynb and described in Chapter 3. The code first determines the namespace:

    try:
      namespace=""
      if "Pinecone" in user_message or "RAG" in user_message:
        # Determine the keyword
        if "Pinecone" in user_message:
            namespace="genaisys"
        elif "RAG" in user_message:
            namespace="data01"
        print(namespace)
…

如果用户消息包含“Pinecone”，则查询将指向genaisys包含指令场景的命名空间。genaisys命名空间的实现方式与静态命名空间有所不同。数据检索将我们带入到智能体、动态决策的阶段，从而触发指令或任务。如果用户消息包含“RAG”，则查询将针对包含静态数据的命名空间。Pinecone 索引的查询和内容在第 3 章data01中已实现：

If the user message contains “Pinecone,” the query will target the genaisys namespace, which contains the instruction scenarios. The genaisys namespace implementation departs from static data retrieval and takes us into agentic, dynamic decision-making to trigger an instruction or a task. If the user message contains “RAG,” the query will target the data01 namespace, which contains static data. The queries and content of the Pinecone index are those implemented in Chapter 3:

        #define query text
        query_text=user_message
        # Retrieve query results
        query_results = get_query_results(query_text, namespace)
        # Process and display the results
        print("Processed query results:")
        qtext, target_id = display_results(query_results)
        print(qtext)

查询结果返回后，我们将用户消息附加到结果中，以扩充输入：

Once the query result is returned, we append the user message to it to augment the input:

        #run task
        sc_input=qtext + " " + user_message
        mrole = "system"
        mcontent = "You are an assistant who executes the tasks you are asked to do."
        user_role = "user"

消息参数和 OpenAI API 调用在第 1 章的“设置环境”部分中进行了描述。OpenAI 响应存储在：task response

The message parameters and the OpenAI API call are described in the Setting up the environment section of Chapter 1. The OpenAI response is stored in task response:

        task_response = openai_api.make_openai_api_call(
            sc_input,mrole,mcontent,user_role
        )
        print(task_response)

OpenAI API 调用返回的响应，结合 Pinecone 查询的结果，存储在aug_output：

The response returned by the OpenAI API call, augmented with the result of the Pinecone query, is stored in aug_output:

        aug_output=namespace + ":" +task_response

如果用户消息中不包含触发 RAG 功能的关键字，则用户请求将被视为无效。直接发送到 OpenAI API 调用，响应将存储在aug_output。但是，系统必须首先检查 是否user_memory为True。系统还必须提取 的文本内容user_message：

If the user message does not contain a keyword to trigger the RAG function, the user request will be sent directly to the OpenAI API call, and the response will be stored in aug_output. However, the system must first check whether user_memory is True or not. The system must also extract the text content of user_message:

      else:
        if user_memory:
                # Extract ALL user messages from the conversation history
                user_messages_content = [
                    msg["content"] for msg in messages
                    if msg["role"] == "user" and "content" in msg
                ]
                # Combine all extracted user messages into a single string
                combined_user_messages = " ".join(user_messages_content)
                # Add the current user_message to the combined text
                umessage = f"{combined_user_messages} {user_message}"
   

在这种情况下，umessage现在包含了从中提取并存储在其中的活跃用户的对话历史记录combined_user_messages以及用户消息本身user_message。生成式人工智能模型现在拥有了与该用户对话的完整上下文。

In this case, umessage now contains a concatenation of the conversation history of the active user extracted and stored in combined_user_messages and the user message itself in user_message. The generative AI model now has complete context about the dialogue with this user.

在某些情况下，我们可能会决定完全忽略对话历史记录。在这种情况下，我们将user_memory参数设置为False`false`，系统将忽略之前的交流：

In some cases, we might decide to ignore the conversation history altogether. In that scenario, we set the user_memory parameter to False, and the system disregards prior exchanges:

        else:
                umessage = user_message

现在该umessage变量已准备好直接发送给生成式人工智能模型：

The umessage variable is now ready to be sent directly to the generative AI model:

        mrole = "system"
        mcontent = "You are an assistant who executes the tasks you are asked to do."
        user_role = "user"
        task_response =openai_api.make_openai_api_call(
            umessage,mrole,mcontent,user_role
        )
        aug_output=task_response

回应然后，将 OpenAI API 调用返回给该函数（图 4.2中的chat_with_gpt节点10）：

The response from the OpenAI API call is then returned to the chat_with_gpt function (in node 10 of Figure 4.2):

      # Return the augmented output
      return aug_output

如果 OpenAI API 调用失败，则会引发并返回一个异常：

If the OpenAI API call fails, an exception is raised and returned:

    except Exception as e:
        # Return the error message in case of an exception
        return f"An error occurred: {str(e)}"

至此，我们已经整合了前三章中开发的生成式人工智能功能。目前，我们构建了一个响应式的 GenAISys 界面，并集成了一个生成式代理，共同构成了一个完整的 AI 控制器和协调器。现在，让我们启动 GenAISys 吧。

And with that, we have assembled the generative AI functionalities developed across the previous three chapters. At this stage, we’ve built a responsive GenAISys interface and integrated a generative agent, together forming a cohesive AI controller and orchestrator. Let’s now put our GenAISys into motion.

多用户、多回合 GenAISys 会话

Multi-user, multi-turn GenAISys session

我们现在拥有一个响应迅速、事件驱动的GenAISys系统，能够如图 4.4所示，我们将探索使用 IPython 构建的 GenAISys 接口的灵活性，并将前几章中的 OpenAI 和 Pinecone 组件组装起来。

We now have a responsive, event-driven GenAISys capable of executing multiple tasks in diverse ways, as illustrated in Figure 4.4. We will explore the flexibility of this GenAISys interface we built using IPython and assemble the OpenAI and Pinecone components from previous chapters.

图 4.4：总结本章中我们构建和组装的各个组件

Figure 4.4: Summing up the components we have built and assembled in this chapter

由于 GenAISys 的功能是事件驱动的，用户（人或系统）或用户组可以利用此框架处理多个跨领域任务。该系统以人为本，在人与生成式人工智能代理之间创建了一个协作、无摩擦的环境。重要的是，在这个框架中，人与人工智能之间不存在竞争。团队可以在使用 GenAISys 大幅提升绩效和生产力的同时，与同事保持良好的人际关系。这种以人为本的方法正是我数十年来一直倡导的。我们拥有为全球企业、中型企业和小型组织提供人工智能驱动的自动化解决方案的丰富经验。当团队将人工智能视为协作工具而非竞争对手时，就能营造积极的氛围，从而快速取得成效——这充分展现了团队合作与技术相结合的强大力量。

Since the functions within GenAISys are event-driven, a user (human or system) or a group of users can leverage this framework to address multiple cross-domain tasks. The system is human-centric, creating a collaborative, frictionless environment between humans and a generative AI agent. Importantly, there is no competition between humans and AI in this framework. Teams can maintain human social relationships with co-workers while using the GenAISys to boost their performance and productivity exponentially. This human-centric approach is one I have always advocated throughout my decades of experience providing AI-driven automation solutions for global corporations, mid-sized businesses, and smaller organizations. When teams adopt AI as a collaborative tool rather than a competitor, it fosters a positive atmosphere that leads to quick wins—demonstrating the combined effectiveness of teamwork and technology.

如果我们深入研究如何在团队协作场景中利用 GenAISys 框架，我们可以确定现实世界项目中通常需要的几个基本事件序列：

If we look deeper into how the GenAISys framework can be leveraged in teamwork scenarios, we can establish several fundamental sequences of events typically needed in real-world projects:

1. 用户选择 => 输入 => 代理已检查 => RAG 指令 => GenAI 代理 => 输出
1. User selection => Input => Agent checked => RAG instruction => GenAI agent => Output
2. 用户选择 => 输入 => 代理已检查 => RAG 数据 => GenAI 代理 => 输出
3. User selection => Input => Agent checked => RAG data => GenAI agent => Output
4. 用户选择 => 输入 => 代理已检查 => 用户历史记录 => GenAI 代理 => 输出
5. User selection => Input => Agent checked => User history => GenAI agent => Output
6. 用户选择 => 输入 => 代理已检查 => 无用户历史记录 => GenAI 代理 => 输出
7. User selection => Input => Agent checked => No user history => GenAI agent => Output
8. 用户选择 => 输入 => 代理未选中 => 输出
9. User selection => Input => Agent unchecked => Output

这些基本序列构成一个序列集S：

These basic sequences constitute a set of sequences, S:

为了实现单个用户或一组用户的目标，可以按如下方式组合序列：

To achieve a goal for a single user or a group of users, the sequences can be assembled as follows:

• {a, b}: 使用 RAG 进行情感分析，然后检索过去会议的情景记忆。
• {a, b}: Running a sentiment analysis with RAG, followed by the retrieval of an episodic memory of a past meeting.
• {d, e}：运行 OpenAI API 请求，然后向其他用户发表评论。此案例的新颖之处在于，AI 代理始终作为团队成员，有时不会表达自己的想法，而是让团队思考它提出的观点。
• {d, e}: Running an OpenAI API request and then making a comment for other users. The novelty in this case is that the AI agent remains a co-worker in a team and sometimes doesn’t express itself, allowing the team to ponder the ideas it suggested.

这些序列根据具体任务和场景的需要，可以将这些序列安排成更长的会话流程。由于序列可以重复，因此我们可以得到无数种可能的动态组合。例如，以下示例展示了这种灵活性：

These sequences can be arranged into longer session flows as required by the specific tasks and scenarios. Because sequences can repeat themselves, we have an indefinite number of possible dynamic combinations. For instance, here’s a glimpse into the flexibility that this provides:

• 三个元素的集合，例如 {a, c, e}、{b, d, e}、{a, b, c}
• Set of three members, such as {a, c, e}, {b, d, e}, {a, b, c}
• 四个元素的集合，例如 {a, b, c, d}、{b, c, d, e}、{a, c, d, e}
• Set of four members, such as {a, b, c, d}, {b, c, d, e}, {a, c, d, e}
• 五个成员的集合，例如 {a, b, c, d, e}
• Set of five members, such as {a, b, c, d, e}

我们可以为这些序列添加退出会话和摘要功能，以及重新加载已保存的文件并继续会话的功能。此外，还可以重复使用某些集合、使用不同用户的集合，以及使用包含更多功能的集合。在接下来的章节中，我们将添加图像生成、音频、网络搜索和机器学习等新功能，从而扩展我们构建的 GenAISys 框架的功能范围。

We could add exiting the session and summarizing to these sequences, as well as reloading a saved file and continuing the session. There can also be a repetition of sets, sets with different users, and sets with more functions. In the following chapters, we will add new features, including image generation, audio, web search, and ML, that will expand the scope of the GenAISys framework we have built.

不过，在本节中，我们将先运行一个包含两名用户的简单会话，并模拟一系列事件。然后，我们将运行一个包含多名用户和一些基本流程的场景。让我们从一个简单的事件序列开始。

In this section, however, we will run a session with two users in a simple sequence of events. Then, we will run a scenario with multiple users and some basic sequences. Let’s begin with a straightforward sequence of events.

与两位用户的会话

A session with two users

在这个示例会话中，两位用户协作集思广益，为他们在线旅游网站上的客户推荐有吸引力的旅游目的地。我们首先运行一个界面会话，然后显示对话历史记录，最后总结讨论内容。要开始会话，请打开Event-driven_GenAISys_framework.ipynb并运行以下单元格：

In this example session, two users collaborate to brainstorm ideas for attractive travel destinations they could recommend to customers on their online travel website. We start by running an interface session, then display the conversation history, and finally summarize the discussion. To begin the session, open Event-driven_GenAISys_framework.ipynb and run these sections of cells:

• 设置环境：运行所有单元格
• Setting up the environment: Run all cells
• 对话代理：运行单单元格
• Conversational agent: Run the single cell
• 在 GenAISys IPython 接口中运行该接口：这将初始化对话。
• Running the interface in the GenAISys IPython interface: This will initialize the conversation

对话已启动，现在让我们运行交互式会话。

With the conversation initialized, let’s now run the interactive session.

互动对话

The interactive conversation

默认情况下，对话开始时User01会显示输入框和已激活代理复选框。图 4.5展示了此场景中触发的事件和功能的顺序。

The conversation starts with User01 by default, displaying the input box and the activated agent checkbox. The sequence of events and functions triggered in this scenario is illustrated in Figure 4.5.

图 4.5：GenAI 代理利用用户历史记录执行任务

Figure 4.5: The GenAI agent performs a task with the user’s history

流程按以下顺序进行：

The flow follows this sequence:

用户选择 => 输入 => 代理已检查 => 用户历史记录 => GenAI 代理 => 输出

User selection => Input => Agent checked => User history => GenAI agent => Output

对用户而言，这个过程是无缝衔接的，如图 4.6所示。然而，底层功能的实现需要精心的设计和开发，才能达到这种流畅的效果。

To the user, this process is seamless, as illustrated in Figure 4.6. However, the underlying functions required careful design and development to produce this smooth effect.

图 4.6：已勾选 GenAI 代理的 UI

Figure 4.6: UI with the GenAI agent checked

从用户的角度来看，这个过程很简单。User01只需在输入框中输入提示信息即可：What is the capital of France?。

From the user’s perspective, the process is straightforward. User01 types a prompt into the input box: What is the capital of France?.

图 4.7：用户输入简单提示

Figure 4.7: User entering a simple prompt

输出结果将显示在输入控件上方，如下图所示：

The output will be displayed above the input widget, as shown here:

图 4.8：输出显示在输入框上方

Figure 4.8: Output is displayed above the input box

到了这一点，即使是未经培训的用户可以根据一份单页文档中提供的基本信息直观地运行 GenAISys。User01接下来提出一个后续问题：

At this point, even an untrained user can intuitively run the GenAISys with the basic information provided in a one-page document. User01 continues with a follow-up question:

User01: What is there to visit?

由于对话代理中启用了用户历史记录选项True，因此代理知道问题与巴黎有关，并提供了一些值得参观的标志性景点的信息：

Since the user history option is set to True in the conversational agent, the agent knows that the question is about Paris and provides information on some iconic locations to visit:

Agent: The capital of France is Paris. There are numerous attractions to visit in Paris, including: 1. **Eiffel Tower** - An iconic symbol of Paris, offering stunning views of the city. 2. **Louvre Museum** - The world's largest art museum, home to the Mona Lisa…

User02现在，用户02通过下拉菜单进入对话，如图4.9所示。然后，用户02询问西班牙的首都是什么，代理做出回应，并将输出显示在输入框上方。

User02 now enters the dialogue by selecting User02 in the drop-down menu, as shown in Figure 4.9. User02 then asks what the capital of Spain is, the agent responds, and the output is displayed above the input box.

图 4.9：输入：其他用户可以加入对话

Figure 4.9: Input: Another user can enter the conversation

至此，GenAISys 的核心框架已搭建完成，我们将在后续章节中逐步完善它，例如介绍安全性、用户访问控制和数据隐私等功能。User02接下来，系统会进一步询问值得一游的地方。由于用户历史记录选项已启用，代理程序能够正确响应：

At this point, the GenAISys core framework is set, and we will progressively enhance it in subsequent chapters by addressing features such as security, user access controls, and data privacy. User02 goes further and asks about the places worth visiting. The agent responds correctly because the user history option is activated:

User02: What is there to visit?

Agent: The capital of Spain is Madrid. There are many attractions to visit in Madrid, including: 1. **The Royal Palace of Madrid** - The official residence of the Spanish royal family, although it is now used only for state ceremonies. 2. **Prado Museum** …

现在，一个关键特性发挥作用了。如图 4.10User02所示，它会停用 AI 代理，并直接……地址User01，类似于在社交媒体或远程协作平台上的互动。

Now, a key feature comes into play. User02 deactivates the AI agent, as shown in Figure 4.10, and directly addresses User01, similar to an interaction on social media or remote collaboration platforms.

图 4.10：团队中不使用人工智能代理的直接沟通

Figure 4.10: Direct communication in a team without an AI agent

User01非正式地回应道：“是的，这是个好主意，但我们再考虑一下。”随后，User01通过输入结束会话。如图 4.11exit所示，此功能将我们的 GenAISys 提升到了一个新的水平，适用于本书将要探讨的用例，例如以下配置：

User01 responds informally: “Yes, that’s a good idea, but let’s think it over.” Subsequently, User01 ends the session by typing exit. This capability, as illustrated in Figure 4.11, takes our GenAISys to a new level for the use cases we will explore in this book, such as the following configurations:

• 用户可以单独与 GenAISys 进行一对一对话。
• A user can communicate with GenAISys alone in a one-to-one conversation
• 团队可以协同工作，借助人工智能代理作为合作者来提升绩效。
• A team can work together, enhancing their performance with the AI agent as a collaborator
• 用户可以是人工智能代理，在真人经理不在时，从不同地点扮演经理的角色。
• The users can be AI agents playing the role of managers from different locations when the human managers are not available
• 用户可以是向人类用户实时提供信息的系统。
• The users can be systems providing information in real-time to human users

图 4.11：团队直接沟通后结束会议

Figure 4.11: A team communicates directly and then ends the session

退出时，会话结束，对话历史记录保存到conversation_history.json文件中：

Upon exiting, the session ends, and the conversation history is saved to the conversation_history.json file:

图 4.12：保存并结束对话

Figure 4.12: Saving and concluding the conversation

像所有该框架的其他特性之一是，退出行为可以根据具体项目进行自定义。请看以下示例：

Like all other features in this framework, the exit behavior can be customized for individual projects. Take the following examples:

• 对话记录可以保存，也可以不保存。
• The conversation history can be saved or not
• 只能保存部分对话记录。
• Only parts of the conversation history can be saved
• 已保存的对话历史记录文件名可以包含时间戳。
• The name of the saved conversation history file can contain a timestamp
• 是否参加"…to the next cell" 由您决定
• Going "…to the next cell" is optional

这些决策需要根据具体应用场景来制定。它们不会改变 GenAISys 的整体框架，但可以实现高度的定制化。

These are decisions to make for each use case. They will not modify the overall framework of the GenAISys but allow for a high level of customization.

在这种情况下，团队想要展示他们刚刚进行的对话。

In this case, the team wants to display the conversation they just had.

加载并显示对话

Loading and displaying the conversation

代码此功能为标准用于将 JSON 文件转换conversation_history.json为 Markdown 格式的 IPython 显示函数。首先，我们检查会话历史记录参数和/或摘要参数是否已启用：

The code for this function is a standard IPython display function to convert the JSON file, conversation_history.json, into Markdown format. Let’s first check whether the conversation history parameter and/or the summary parameter is activated:

display_conversation_history=True
summary=True

在这种情况下，对话历史记录和摘要功能都已启用。现在，我们将检查对话历史记录文件是否存在：

In this case, the conversation history and the summary function are both activated. Now, we will check whether a conversation history file is present or not:

import json
from IPython.display import display, Markdown
import os
if display_conversation_history == True or summary==True:
    # File path
    file_path = 'conversation_history.json'
    # Check if the file exists
    if os.path.exists(file_path):
        display_conversation_history=True
        summary=True
        print(f"The file '{file_path}' exists.")
    else:
        display_conversation_history=False
        summary=False
        print(f"The file '{file_path}' does not exist.")
        print("The conversation history will not be processed.")

如果文件存在，display_conversation_history将设置为True（summary=True即使False之前已设置为）。消息将表明文件已存在：

If a file exists, display_conversation_history will be set to True and summary=True (even if it was set to False previously). A message will signal that the file exists:

The file 'conversation_history.json' exists.

如果display_conversation_history==True，则会显示对话内容：

If display_conversation_history==True, then the conversation will be displayed:

# Display option
if display_conversation_history==True:
  # File path
  file_path = 'conversation_history.json'
  # Open the file and read its content into the 'dialog' variable
  with open(file_path, 'r', encoding='utf-8') as file:
      dialog = json.load(file)  # Parse JSON content
…
# Function to format JSON content as markdown
def format_json_as_markdown(data, level=0):
    html_output = ""
    indent = "  " * level
…
return html_output
# Format the JSON into markdown
formatted_markdown = format_json_as_markdown(dialog)
# Display formatted JSON as Markdown
display(Markdown(formatted_markdown))

输出格式良好：

The output is nicely formatted:

…
User01:
role:
user
content:
What is the capital of France?
role:
assistant
content:
The capital of France is Paris.
…
Content:
The capital of Spain is Madrid.
role:
user
content:
What is there to visit?
role:
assistant
content:
The capital of Spain is Madrid. There are many attractions to visit in Madrid, including:
The Royal Palace of Madrid – …

这团队展示了对话内容但他希望进一步推进这一过程，并总结这次有人工智能代理参与的在线会议。

The team has displayed the conversation but wants to take the process further and summarize this online meeting that included an AI agent as a participant.

加载并总结对话

Loading and summarizing the conversation

我们总结的这段对话展示了如何将人工智能代理融入现有的人类团队。为了提高生产力。在某些情况下，GenAISys 可以独立完成自动化任务。在其他情况下，GenAISys 可以作为一位或多位用户的辅助工具。还有一些情况下，在组织运营的诸多关键时刻，人类团队和人工智能代理可以协同工作，共同做出决策。

The conversation we are summarizing shows how to merge an AI agent into an existing human team to boost productivity. In some cases, the GenAISys will have worked on automated tasks alone. In other cases, the GenAISys will be the copilot of one or several users. In others, in the many critical moments of the life of an organization, teams of humans and AI agents will be able to work together to make decisions.

在本节中，我们将要求人工智能代理总结对话。我们将在后续章节中把此功能集成到 GenAISys 中。目前，我们将在显示对话后单独运行此操作，如图4.13所示。

In this section, we will ask the AI agent to summarize the conversation. We will integrate this feature as a function in the GenAISys in the following chapters. For the moment, we will run it separately after displaying the conversation, as shown in Figure 4.13.

图 4.13：显示和总结对话

Figure 4.13: Displaying and summarizing a conversation

代码首先，像显示函数那样加载conversation_history.json文件。然后，我们定义一个转换函数。将对话历史记录内容转换为 OpenAI API 的最佳格式：

The code first loads the conversation_history.json file as in the display function. Then, we define a function that converts the conversation history content into an optimal format for the OpenAI API:

# Function to construct dialog string from the JSON conversation history
def construct_dialog_for_summary(conversation_history_json):
    dialog = ""
    for user, messages in conversation_history_json.items():
        dialog += f"\n{user}:\n"
        for message in messages:
            role = message["role"]
            content = message["content"]
            dialog += f"- {role}: {content}\n"
    return dialog

用于构建完整对话历史记录的函数名为：

The function to construct the full conversation history is called:

# Construct the full dialog from the JSON history
formatted_dialog = construct_dialog_for_summary(conversation_history_json)

现在，我们准备完整的消息，用于为系统构建的自定义 GenAISys API 调用，该调用已导入到笔记本中“设置环境”部分的OpenAI子部分：

Now, we prepare the complete message for the custom GenAISys API call built for the system and imported in the OpenAI subsection of the Setting the environment section in our notebook:

# Task to summarize the conversation
mrole = "system"
mcontent = "Your task is to read this JSON formatted text and summarize it."
user_role = "user"
task = f"Read this JSON formatted text and make a very detailed summary of it with a list of actions:\n{formatted_dialog}"

最后，我们调用 GenAISys OpenAI 函数：

Finally, we call the GenAISys OpenAI function:

# The make_openai_api_call function is called
task_response = openai_api.make_openai_api_call(
    task, mrole, mcontent, user_role
)

API响应代码将以 Markdown 格式显示：

The API response code will be displayed in Markdown format:

from IPython.display import Markdown, display
# Display the task response as Markdown
display(Markdown(task_response))

现在，一切已准备就绪。如果满足以下条件，我们可以调用汇总函数summary==True：

Now, everything is ready. We can call the summarizing function if summary==True:

if summary==True:
    # File path to the JSON file
    file_path = '/content/conversation_history.json'
    # Check if the file exists before calling the function
    if os.path.exists(file_path):
        summarize_conversation(file_path)
    else:
        print(f"File '{file_path}' does not exist. Please provide a valid file path.")

  file_path = ‘/content/conversation_history.json’ or
 file_path = ‘conversation_history.json’

输出结果是对话历史记录的摘要，包含引言和详细摘要。我们可以修改摘要提示，使其长度可长可短。我们还可以设计提示，让生成式 AI 模型针对对话的特定部分，或者为特定项目设计其他任何特定提示。在这种情况下，输出结果令人满意：

The output is a summary of the conversation history that contains an introduction and then a detailed summary. The prompt for this summary can be modified to request shorter or longer lengths. We can also design a prompt asking the generative AI model to target part of the conversation or design any other specific prompt for a given project. In this case, the output is satisfactory:

The JSON formatted text contains interactions between users and an assistant, where users inquire about the capitals of France and Spain and seek recommendations for attractions to visit in these cities. Below is a detailed summary with a list of actions:
User01 Interaction:
1. Question about the Capital of France:
    User01 asks for the capital of France.
    The assistant responds that the capital of France is Paris.
2. Inquiry about Attractions in Paris:
    User01 asks what there is to visit in Paris.
    The assistant provides a list of notable attractions in Paris:
    1. Eiffel Tower - Iconic symbol and must-visit landmark.
    2. Louvre Museum - Largest art museum, home to the Mona Lisa….

跑步通过多种可能的方式通过一系列任务和事件，我们已经见识了GenAISys的灵活性。接下来，让我们运行一个更复杂的多用户会话。

By running through the many possible sequences of tasks and events, we have seen the flexibility that the GenAISys offers us. Let’s run a more complex multi-user session.

多用户会话

Multi-user session

在本节中，我们将运行一次技术演示，激活我们在前几章和本章中构建的主要功能：

In this section, we will run a technical session that activates the main functions we have built in the previous chapters and this chapter:

• 语义和情感分析
• Semantic and sentiment analysis
• RAG 用于情景记忆提取
• RAG for episodic memory retrieval
• 不使用人工智能对话代理的对话
• A dialogue without an AI conversational agent
• 加载、显示和汇总对话历史记录
• Loading, displaying, and summarizing the conversation history

如果您没有中断之前的会话，只需在我们的笔记本中再次运行GenAISys IPython 接口单元格中的“运行接口”部分，即可开始一个新的会话。

If you haven’t interrupted the previous session, then simply run the Running the interface section in the GenAISys IPython interface cell again in our notebook, which will start a new conversation.

如果您是从零开始，那么要开始会话，请打开Event-driven_GenAISys_framework.ipynb并运行以下单元格部分：

If you are starting from scratch, then to start the session, open Event-driven_GenAISys_framework.ipynb and run the following sections of cells:

• 环境设置：所有细胞
• Setting up the environment: All the cells
• 对话代理：包含一个单元格
• Conversational agent: Contains one cell
• 在 GenAISys IPython 接口中运行该接口：将开始对话
• Running the interface in the GenAISys IPython interface: Will start the conversation

我们准备探索 GenAISys 的一些高级功能。我们将重点介绍每个提示所激活的事件和功能。本次会话的第一个环节是语义和情感分析。

We are ready to explore some advanced features of the GenAISys. We will highlight the events and functions that are activated by each prompt. The first sequence in the session is semantic and sentiment analysis.

语义和情感分析

Semantic and sentiment analysis

执行我们需要进行语义和情感分析。按照图 4.14所示的 GenAISys 编排的以下序列运行：

To perform semantic and sentiment analysis, we will need to run the following sequence orchestrated by the GenAISys as shown in Figure 4.14:

• 1. 用户选择功能未启用，因为User01会话开始时默认用户即为当前用户。根据具体使用场景，我们可以将此用户称为“主机”。
• 1. User selection is not activated because User01 is the default user at the beginning of a session. We could call this user the “host” if we wish, depending on the use case.
• User01在第 2 步输入。第 3 步输入触发。已检查代理，这是会话开始时的默认值。
• User01 enters an input at 2. Input triggering 3. Agent checked, which is checked as the default value when the session starts.
• AI 对话式 AI 控制器接管，解析提示，Pinecone在提示中查找关键字，在指令场景命名空间中触发 Pinecone 查询，增强提示，并触发4. GenAI 代理。
• The AI conversational AI controller takes over, parses the prompt, finds the Pinecone keyword in the prompt, triggers a Pinecone query in the instruction scenario namespace, augments the prompt, and triggers 4. GenAI agent.
• 4. GenAI 代理触发对 GPT-4o 的 API 调用并返回响应。
• 4. GenAI agent triggers an API call to GPT-4o and returns the response.
• 5. 输出触发显示更新。系统已准备好接收新的输入。
• 5. Output triggers the updating of the display. The system is ready for a new input.